brawl 0.0.0.alpha → 0.0.3

data/_spike/DRb/battle_controller.rb

@@ -0,0 +1,54 @@
+#require 'uuidtools'
+$DEBUG = true
+
+require_relative 'arena'
+require_relative 'server'
+require_relative 'bot_runner'
+
+class RunIt
+  def run(server, code)
+    bot = BotRunner.new(code)
+    fork do
+      Signal.trap("HUP") { puts "Die! #{server}"; bot.stop; exit}
+      bot.connect(server)
+      bot.run
+      while true
+        sleep(0.25)
+      end
+    end
+  end
+end
+
+arena = Arena.new
+code = File.read("test_bot.rb")
+puts "test code: #{code}"
+client_id1 = "client1"
+arena_proxy1 = ArenaProxy.new(arena, client_id1)
+arena.add_bot(client_id1)
+bot1_server = Server.new
+bot1_server.start(object: arena_proxy1)
+r1 = RunIt.new
+pid1 = r1.run(bot1_server.uri, code)
+
+client_id2 = "client2"
+arena_proxy2 = ArenaProxy.new(arena, client_id2)
+arena.add_bot(client_id2)
+bot2_server = Server.new
+bot2_server.start(object: arena_proxy2)
+r2 = RunIt.new
+pid2 = r2.run(bot2_server.uri, code)
+
+timeout = Time.now + 3
+while Time.now < timeout
+  sleep(0.05)
+end
+bot1_server.stop
+Process.kill("HUP", pid1)
+sleep(2.0)
+bot2_server.stop
+Process.kill("HUP", pid2)
+Process.wait
+
+
+
+

data/_spike/DRb/bot.rb

@@ -0,0 +1,23 @@
+module Brawl
+class Bot
+  
+  def initialize(msg, response)
+    @msg      = msg
+    @response = response
+  end
+  
+  def move(amount)
+    @msg.clear
+    @msg.concat [:move, amount]
+    sleep(0.05) while @response.empty?
+    return_value = Marshal.load(Marshal.dump(@response))
+    @response.clear
+    return_value
+  end
+  
+  def loop
+    yield self
+  end
+  
+end
+end

data/_spike/DRb/bot_runner.rb

@@ -0,0 +1,110 @@
+require 'drb'
+require_relative 'bot'
+
+class BotRunner
+
+  attr_reader :proxy
+  
+  def initialize(code)
+    @mutex = Mutex.new
+    make_run(code)
+  end
+  
+  def connect(server)
+    @server = server
+    @run = true
+    puts "connecting: #{@server}"
+    DRb.start_service
+    @proxy = DRbObject.new(nil, server)
+  end
+  
+  def stop
+    @run = false
+    DRb.stop_service
+  end
+
+
+  # def run
+  #   Thread.start {
+  #     msg = []
+  #     response = []
+  #     Thread.start {
+  #       $SAFE = 1
+  #       code = Brawl::Bot.new(msg, response)
+  #       while @run
+  #         sleep(rand(0))
+  #         code.loop do |bot|
+  #           puts "bot code loop"
+  #           value = @proxy.move([rand(3)])
+  #           puts "value: #{value}"
+  #         end
+  #       end
+  #     }
+  #   }
+  # end
+
+
+  # def run
+  #   Thread.start {
+  #     msg = []
+  #     response = []
+  #     Thread.start {
+  #       $SAFE = 3
+  #       code = Brawl::Bot.new(msg, response)
+  #       while @run
+  #         sleep(rand(0))
+  #         code.loop do |bot|
+  #           puts "bot code loop"
+  #           value = bot.move rand(3)+1
+  #           puts "value: #{value}"
+  #         end
+  #       end
+  #     }
+  #     while @run
+  #       sleep(0.05) while msg.empty?
+  #       puts "got a message"
+  #       sleep(0.25)
+  #       proxy_response = @proxy.send msg.first, msg[1..-1]
+  #       msg.clear
+  #       response << proxy_response
+  #     end
+  #   }
+  # end
+
+  private 
+  
+  def make_run(code)
+    method = 
+    %Q{
+      def run
+        Thread.start {
+          msg = []
+          response = []
+          Thread.start {
+            $SAFE = 3
+            code = Brawl::Bot.new(msg, response)
+            while @run
+              puts "looping"
+              sleep(rand(0))
+              #{code}
+            end
+          }
+          while @run
+            sleep(0.05) while msg.empty?
+            puts "got a message"
+            sleep(0.25)
+            proxy_response = @proxy.send msg.first, msg[1..-1]
+            msg.clear
+            response << proxy_response
+          end
+        }
+      end
+    }
+    instance_eval(method)
+  end
+  
+  def send(msg)
+    @msg = msg
+  end
+  
+end

data/_spike/DRb/comment.txt

@@ -0,0 +1,11 @@
+I've started a rewrite on this app to fix all the horrible Demeter violations and just bad design all around but in the process I've come up with a rough version of a security model.
+
+Can you guys take a look and tell me what you think?
+
+[https://github.com/mikbe/Brawl/blob/master/_spike/DRb/bot.rb](https://github.com/mikbe/Brawl/blob/master/_spike/DRb/bot.rb)
+
+You can run the battle_controller.rb file and it should load up everything else. It demonstrates two bots running through the same arena.
+
+The code for the bot is as safe as $SAFE can make it while still allowing the user to do very basic things like make an array ($SAFE = 3). Plus it's isolated into another process from the rest of the code, including other bots, and uses DRb to communicate inter-process. There's probably a simpler way of doing that communication but that was actually pretty easy. Oh and an ArenaProxy class is used so all of the Arena methods and properties aren't exposed to the bots.
+
+The reason I'm doing the weird array messaging in two looping threads is because DRb will only work at $SAFE 1 or 0.

data/_spike/DRb/server.rb

@@ -0,0 +1,28 @@
+require 'drb'
+
+class Server
+  
+  def start(params)
+    port    = params[:port] ? "druby://:#{params[:port]}" : nil
+    object  = params[:object]
+    @service = DRb.start_service(port, object)
+  end
+  
+  def stop
+    @service.stop_service
+  end
+  
+  def uri
+    @service.uri
+  end
+  
+end
+
+# server = Server.new
+# server.start(object: ArenaProxy.new)
+# puts server
+# puts server.uri
+# DRb.thread.join
+
+
+

data/_spike/DRb/test_bot.rb

@@ -0,0 +1,6 @@
+puts "running test_bot"
+code.loop do |bot|
+  puts "bot code loop"
+  value = bot.move rand(3)+1
+  puts "value: #{value}"
+end

data/_spike/array.rb

@@ -0,0 +1,7 @@
+require 'benchmark'
+
+Benchmark.bmbm do |bm|
+  bm.report {x = []; 100000.times {x << "A"}}
+  bm.report {x = []; 10000.times {x.concat ["A"]}}
+  bm.report {x = []; 100000.times {x.push "A"}}
+end

data/_spike/atan2.rb

@@ -0,0 +1,39 @@
+
+def to_radians(angle)
+  angle * (Math::PI / 180)
+end
+
+def to_degrees(angle)
+  angle * (180.0 / Math::PI)
+end
+
+# x1, y1 = 5,5
+# x2, y2 = 6,6
+# x2, y2 = 5,5
+# x1, y1 = 6,6
+
+x1, y1 = 5,5
+x2, y2 = 5,6
+puts "0 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 6,6
+puts "45 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 6,5
+puts "90 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 6,4
+puts "135 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 5,4
+puts "180 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 4,4
+puts "225 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 4,5
+puts "270 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+
+x2, y2 = 4,6
+puts "315 : #{to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360}"
+

data/_spike/battle.rb

@@ -0,0 +1,202 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'brawl'
+$DEBUG=true
+Thread.abort_on_exception
+
+module Brawl
+
+  class CommandSync
+
+    attr_reader :ticks, :run
+
+    def initialize(min_time=0.5)
+      @min_time = min_time
+      @run      = :wait
+      @ticks    = 0
+    end
+
+    def start
+      @run = :run
+      Thread.start{
+        until @run == :stop
+          sleep(@min_time)
+          #puts "incrementing ticks: #{@ticks}"
+          @ticks += 1
+        end
+        puts "Command sync stopped "
+      }
+    end
+    
+    def stop
+      @run = :stop
+    end
+
+  end
+
+  class Proxy
+    
+    attr_accessor :bot, :name, :last_tick
+    
+    def initialize(params)
+      @sync = params[:sync]
+      
+      # probably just put this all in one object
+      @name = params[:name]
+      @bot  = params[:bot]
+      @code = params[:code]
+      
+      @last_tick = @sync.ticks
+      @run = false
+      add_proxy_methods
+    end
+
+    def add_proxy_methods
+      puts "proxy: #{@bot.public_methods(false)}"
+      @bot.public_methods(false).each do |method|
+        singleton_class.send :define_method, method do |*params, &block|
+          puts "#{@name}: #{method}(#{params.join})"
+          sleep(0.01) while @sync.ticks <= @last_tick
+          @last_tick = @sync.ticks
+          @bot.send method, *params, &block
+          puts "#{@name}: #{@bot.properties[:location]}"
+        end
+      end
+    end
+
+    def start
+      @run = true
+      # for security in produciton will use a process fork but for now...
+      Thread.start {
+        # wait for command sync to start
+        until @sync.run == :stop || !@run
+          sleep(0.01) if @sync.run == :wait
+          if @sync.run == :run
+            instance_eval("Thread.start{$SAFE=3;#{@code}}.join")
+          end
+        end
+        puts "#{@name} stopped"
+        @run = false
+      }
+    end
+
+    def stop
+      @run = false
+    end
+
+    def code
+      yield self
+    end
+
+  end
+  
+  class BattleController
+    
+    attr_accessor :arena, :bots
+    
+    def initialize(params)
+      super
+      
+      @sync = CommandSync.new(params[:min_tick])
+      
+      arena = params[:arena]
+      bots  = params[:bots]
+      @arena = arena[:class].new(arena[:parameters])
+      
+      @bot_proxies = []
+      bots.each do |bot|
+        puts "add: #{bot[:name]}, #{bot[:class]}"
+        bot[:parameters].merge!(location: {x: rand(100), y:rand(100)})
+        
+        bot_instance = bot[:class].new(bot[:parameters].merge(arena: @arena))
+        @bot_proxies << {
+          name:  bot[:name],
+          proxy: Proxy.new(
+            sync: @sync,
+            bot:  bot_instance,
+            code: bot[:code],
+            name: bot[:name]
+          )
+        }
+      end
+    end
+    
+    def start
+      @bot_proxies.each do |bot|
+        puts
+        puts "Starting: #{bot[:name]}"
+        bot[:proxy].start
+      end
+      @sync.start
+    end
+    
+    def stop
+      @sync.stop
+    end
+    
+  end
+
+arena = {
+  class: Arena, 
+  parameters: {
+    size: {width: 100, length: 100}
+  }
+}
+
+bot_code = <<-CODE
+code do |bot|
+  if rand(0) > 0.5
+    bot.turn [:left,:right,:around].sample
+  end
+  bot.move rand(3) + 1
+end
+CODE
+
+bots = [
+  { name: "BasicBot1",
+    class: BasicBot,
+    parameters: {
+      arena: arena,
+      parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 360}}
+    },
+    code:bot_code
+  },
+  { name: "BasicBot2",
+    class: BasicBot,
+    parameters: {
+      arena: arena,
+      parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 360}}
+    },
+    code:bot_code
+  }
+]
+
+battle = Brawl::BattleController.new(
+  arena: arena, 
+  bots: bots,
+  min_tick: 0.01
+)
+
+battle.start
+
+timeout = Time.now + 5
+while Time.now <= timeout
+  sleep(0.1)
+end
+battle.stop
+sleep(1)
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+