brawl 0.0.0.alpha → 0.0.3

data/lib/brawl.rb

@@ -1,5 +1,16 @@
 require "brawl/version"
 
-module Brawl
-  # Your code goes here...
-end
+require "brawl/_helper"
+
+require "brawl/clock"
+
+require "brawl/basic_arena_object"
+require "brawl/wall"
+
+require "brawl/arena"
+
+require "brawl/basic_bot"
+require "brawl/parts"
+require "brawl/bot_proxy"
+
+require "brawl/battle_controller"

data/lib/brawl/_helper.rb

@@ -0,0 +1,65 @@
+module Brawl
+
+  DECIMAL_PLACES  = 1
+
+  class Helper
+
+    def self.to_radians(angle)
+      angle * (Math::PI / 180)
+    end
+
+    def self.to_degrees(angle)
+      angle * (180.0 / Math::PI)
+    end
+
+    # returns a shorter angle if one exists (angle - 180's complement)
+    # e.g. wrap_angle(270)  = -90
+    #      wrap_angle(-320) = 40
+    #      wrap_angle(45)   = 45
+    def self.wrap_angle(angle)
+      # refactor? : can this be simplified?
+      return angle unless angle > 180 || angle < -180
+      (360 - angle.abs) * (angle.abs / angle) * -1
+    end
+
+    def self.point_in_cone?(params)
+
+      origin    = params[:origin]
+      radius    = params[:radius]
+      angle     = params[:angle]
+      direction = params[:direction]
+      point     = params[:point]
+
+      distance_to_target = distance(origin, point)
+      return false if distance_to_target > radius
+
+      bearing_to_target = bearing(origin, point)
+
+      min_cone_angle = (direction - (angle / 2)) % 360
+      max_cone_angle = (direction + (angle / 2)) % 360
+
+      greater_than = bearing_to_target >= min_cone_angle
+      less_than    = bearing_to_target <= max_cone_angle
+
+      if (min_cone_angle > max_cone_angle && (greater_than || less_than)) ||
+      (min_cone_angle <= max_cone_angle && (greater_than && less_than))
+        { distance: distance_to_target.round(DECIMAL_PLACES), 
+          bearing: bearing_to_target}
+        
+      end
+    end
+
+    def self.bearing(origin, target)
+      x1, y1, x2, y2 = origin[:x], origin[:y], target[:x], target[:y]
+      # correct mathy angles to what everyone on the face of the planet uses
+      to_degrees(Math.atan2(x2 - x1, y2 - y1)) % 360
+    end
+
+    def self.distance(point1, point2)
+      x1, y1, x2, y2 = point1[:x], point1[:y], point2[:x], point2[:y]
+      distance = Math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
+    end
+
+  end
+
+end

data/lib/brawl/arena.rb

@@ -0,0 +1,118 @@
+module Brawl
+  
+  class Arena
+    
+    attr_reader :size, :clock
+    
+    def initialize(params={})
+      @size     = params[:size]
+      @objects  = []
+      
+      set_clock(params[:clock])
+
+      add_walls
+    end
+
+    def length
+      @size[:length]
+    end
+
+    def width
+      @size[:width]
+    end
+
+    def ticks
+      @clock.ticks
+    end
+
+    def set_clock(clock=nil)
+      @clock = clock || Clock.new
+      @clock.start
+    end
+
+    def add_object(object)
+      add_objects([object]).first
+    end
+    
+    def add_objects(objects_array)
+      objects_array.collect do |object|
+        if get_object(id: object.id) || ping(object.location)
+          false
+        else
+          !!(@objects << object)
+        end
+      end
+    end
+
+    def remove_object(object)
+      @objects.delete(object)
+    end
+
+    def move_object(object_location_hash)
+      object    = object_location_hash.keys.first
+      location  = object_location_hash.values.first
+
+      return if ping(location)
+      return unless in_bounds?(location)
+
+      !!(object.location = location)
+    end
+
+    # allows searching by object properties like location or id
+    def get_object(property_hash)
+      property, value = property_hash.first
+      @objects.each do |object|
+        return object.properties if object.properties[property] == value
+      end
+      nil
+    end
+
+    def get_all_objects
+      @objects.collect {|object| object.properties}
+    end
+
+    def in_bounds?(location)
+      return false if location[:x] >= @size[:width]  || location[:x] <  0
+      return false if location[:y] >= @size[:length] || location[:y] <  0
+      true
+    end
+
+    def ping(location)
+      get_object(location: location)
+    end
+
+    def forward_damage(params)
+      target = @objects.select{|object| object.id == params[:target]}.first
+      target.damage(params[:damage])
+      end_game if victory?
+    end
+
+    def victory?
+      @objects.one? do |object|
+        object.class != Wall && object.health > 0
+      end ||
+      @objects.none? do |object|
+        object.class != Wall && object.health > 0
+      end
+    end
+
+    def end_game
+      @clock.stop
+    end
+
+    private 
+
+    def add_walls
+      (0...width).each do |col|
+        @objects << Wall.new(location: {x: col, y: -1})
+        @objects << Wall.new(location: {x: col, y: length})
+      end
+      (0...length).each do |row|
+        @objects << Wall.new(location: {x: -1, y: row})
+        @objects << Wall.new(location: {x: width, y: row})
+      end
+    end
+
+  end
+  
+end

data/lib/brawl/basic_arena_object.rb

@@ -0,0 +1,35 @@
+require 'uuidtools'
+
+module Brawl
+
+  class BasicArenaObject
+
+    attr_reader   :id, :clock, :name
+    attr_accessor :location, :heading, :health
+
+    def initialize(params={})
+      @clock      = params[:clock]
+      @id         = params[:id] || UUIDTools::UUID.timestamp_create.to_s
+      @name       = params[:name] || self.object_id
+      @location   = params[:location] || {x: 0, y: 0}
+      @heading    = params[:heading] || 0
+      @health     = params[:health] || 1
+      @properties = params[:properties] || 
+        [:id, :name, :class, :location, :health, :heading]
+    end
+
+    # properties are values that are OK to be publicly 'seen' in the arena
+    def properties
+      @properties.each_with_object({}) do |property, hash|
+        hash[property] = self.send(property)
+      end
+    end
+    
+    def damage(damage_points)
+      @health -= damage_points
+      @health < 0 ? @health = 0 : @health
+    end
+ 
+  end
+
+end

data/lib/brawl/basic_bot.rb

@@ -0,0 +1,69 @@
+require 'forwardable'
+require 'uuidtools'
+require 'eventable'
+
+module Brawl
+
+  class BasicBot < BasicArenaObject
+    extend Forwardable
+
+    include Eventable
+    event :bot_ran_method
+    event :bot_damaged
+
+    attr_reader :parts
+
+    DECIMAL_PLACES = 1
+
+    def initialize(params={})
+      @arena = params[:arena]
+      @parts = params[:parts]
+
+      add_parts(@parts, params)
+      hook_methods_for_listeners
+
+      super
+
+      @arena.add_object(self)
+    end
+
+    def damage(damage_points)
+      super
+      fire_event(:bot_damaged,
+        properties,
+        :damage,
+        damage_points
+      )
+      @arena.remove_object(self) if @health <= 0
+    end
+
+    private
+
+    def add_parts(parts, params)
+      return unless parts
+      parts.each do |part_module, init_params|
+        params.merge! init_params
+        # make sure we can fire the module's initialize method
+        part_module.send :alias_method, :initialize_parts, :initialize
+        extend part_module
+        initialize_parts(params)
+      end
+    end
+
+    def hook_methods_for_listeners
+      public_methods(false).each do |method|
+        next if [:properties,:damage].include?(method)
+        singleton_class.send :alias_method, "_hook_#{method}", method
+
+        singleton_class.send :define_method, method do |*params, &block|
+          return if @health <= 0
+          fire_event(:bot_ran_method, properties, method, *params)
+          send "_hook_#{method}".to_sym, *params, &block
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/brawl/battle_controller.rb

@@ -0,0 +1,97 @@
+require 'eventable'
+
+module Brawl
+
+  class BattleController
+
+    include Eventable
+    event :bot_msg
+    
+    attr_accessor :arena, :bots, :clock
+
+    def initialize(params = {})
+      super
+
+      arena_data = params[:arena]
+      make_arena(arena_data)
+
+      bot_data = params[:bots]
+      make_bots(bot_data)
+
+      clock_data = params[:clock]
+      make_clock(clock_data)
+
+    end
+
+    def make_arena(arena_data)
+      return unless arena_data
+      @arena = Brawl::Arena.new(arena_data)
+    end
+
+    def make_clock(clock_data)
+      return unless clock_data
+      @clock = Clock.new(clock_data[:tick_rate])
+      @arena.set_clock(clock) if @arena
+    end
+
+    def make_bots(bot_data)
+      return unless bot_data
+      
+      @bots = []
+      bot_data.each do |bot_datum|
+        bot_params = bot_datum[:params]
+
+        bot_params.merge!(arena: arena)
+        bot_params.merge!(name: bot_datum[:name])
+        
+        location = {location: {x: rand(arena.width), y:rand(arena.length)}}
+        bot_params.merge!(location)
+
+        bot_instance  = bot_datum[:class].new(bot_params)
+        
+        bot_instance.register_for_event(
+          event:    :bot_ran_method, 
+          listener: self, 
+          callback: :bot_msg_callback
+        )
+        bot_instance.register_for_event(
+          event:    :bot_damaged, 
+          listener: self, 
+          callback: :bot_msg_callback
+        )
+
+        bot_proxy = BotProxy.new(
+          clock:  clock,
+          bot:    bot_instance,
+          code:   bot_datum[:code]
+        )
+
+        @bots << {
+          name:  bot_datum[:name],
+          proxy: bot_proxy
+        }
+      end
+    end
+
+    def bot_msg_callback(*params, &block)
+      fire_event(:bot_msg, *params, &block)
+    end
+
+    def victory?
+      arena.victory?
+    end
+
+    def start
+      @bots.each do |bot|
+        bot[:proxy].start
+      end
+      @clock.start
+    end
+
+    def stop
+      @clock.stop
+    end
+
+  end
+
+end

data/lib/brawl/bot_proxy.rb

@@ -0,0 +1,60 @@
+module Brawl
+
+  class BotProxy
+
+    attr_accessor :bot, :last_tick, :msg_log, :clock
+
+    def initialize(params)
+      @clock      = params[:clock]
+      @bot        = params[:bot]
+      @code       = params[:code]
+
+      @last_tick  = @clock.ticks
+      @run        = false
+
+      add_proxy_methods
+    end
+
+    def name
+      @bot.name
+    end
+
+    def add_proxy_methods
+      # I'm sure there's a better way of doing this
+      combined_methods = @bot.public_methods(false)
+      combined_methods.concat BasicArenaObject.instance_methods(false)
+
+      combined_methods.each do |method|
+        next if method.to_s[0] == "_"
+        singleton_class.send :define_method, method do |*params, &block|
+          sleep(0.01) while @clock.ticks <= @last_tick
+          @last_tick = @clock.ticks
+          @bot.send method, *params, &block
+        end
+
+      end
+    end
+
+    def start
+      @run = true
+      Thread.start {
+        until @clock.state == :stopped || !@run || @health == 0
+          sleep(0.01) if @clock.state == :wait
+          if @clock.state == :running
+            instance_eval("Thread.start{$SAFE=3;#{@code}}.join")
+          end
+        end
+        @run = false
+      }
+    end
+
+    def stop
+      @run = false
+    end
+
+    def code
+      yield self
+    end
+
+  end
+end