brawl 0.0.0.alpha → 0.0.3

data/lib/brawl/clock.rb

@@ -0,0 +1,36 @@
+module Brawl
+  
+  class Clock
+    
+    attr_reader :tick_rate, :ticks, :state
+    
+    def initialize(tick_rate=0.05)
+      @tick_rate  = tick_rate
+      @state      = :wait
+      @ticks      = 0
+    end
+    
+    def start
+      @state = :running
+      ticking
+    end
+    
+    def stop
+      @state = :stopping
+    end
+    
+    private
+    
+    def ticking
+      Thread.start {
+        while @state == :running
+          sleep(@tick_rate)
+          @ticks += 1
+        end
+        @state = :stopped
+      }
+    end
+    
+  end
+  
+end

data/lib/brawl/parts.rb

@@ -0,0 +1,3 @@
+require_relative "parts/basic_motor"
+require_relative "parts/basic_scanner"
+require_relative "parts/basic_weapon"

data/lib/brawl/parts/basic_motor.rb

@@ -0,0 +1,55 @@
+module Brawl
+
+  module BasicMotor
+    
+    attr_reader :move_max, :turn_max
+    
+    def initialize(params={})
+      @move_max = params[:move_max] || 5
+      @turn_max = params[:turn_max] || 90
+    end
+
+    def move(count=1)
+
+      heading_radian = Helper.to_radians((@heading + (count < 0 ? 180 : 0)))
+      count = count.abs
+      count = [count, @move_max].min
+      
+      count.times do 
+        x = @location[:x] + Math.sin(heading_radian).round(DECIMAL_PLACES)
+        y = @location[:y] + Math.cos(heading_radian).round(DECIMAL_PLACES)
+        break unless @arena.in_bounds?({x: x, y: y})
+        @location[:x], @location[:y] = x, y
+      end
+    end
+
+    def turn(params)
+      # refactor
+      if params.is_a?(Hash)
+        turn_to(params[:to_angle])    if params[:to_angle]
+        turn_by(params[:by_degrees])  if params[:by_degrees]
+      else
+        angles = {left: -90, right: 90, around: 180}
+        turn_by(angles[params])
+      end
+    end
+
+    private
+
+    def turn_to(angle)
+      turn_by_angle = Helper.wrap_angle(angle - @heading)
+      turn_by(turn_by_angle)
+    end
+
+    def turn_by(degrees)
+      degrees = boundscheck_angle(degrees)
+      @heading = (@heading + degrees) % 360
+    end
+    
+    def boundscheck_angle(angle)
+      [angle.abs % 360, @turn_max].min * (angle.abs / angle)
+    end
+    
+  end
+
+end

data/lib/brawl/parts/basic_scanner.rb

@@ -0,0 +1,33 @@
+module Brawl
+  module BasicScanner
+    
+    attr_reader :scan_max, :angle_max
+
+    DECIMAL_PLACES  = 1
+    
+    def initialize(params={})
+      @scan_max   = params[:scan_max] || 10
+      @angle_max  = params[:angle_max] || 45
+    end
+
+    def scan(params={})
+      angle = [@angle_max, params[:angle] ||= @angle_max].min
+
+      cone = {
+        origin:     @location,
+        direction:  params[:direction],
+        radius:     @scan_max,
+        angle:      angle,
+      }
+
+      @arena.get_all_objects.collect do |info_hash|
+        next if info_hash[:id] == @id 
+        if obj = Helper.point_in_cone?(cone.merge(point: info_hash[:location]))
+          info_hash.merge(obj)
+        end
+      end.compact
+      
+    end
+  
+  end
+end

data/lib/brawl/parts/basic_weapon.rb

@@ -0,0 +1,47 @@
+module Brawl
+  module BasicWeapon
+    
+    attr_reader :range, :reload_time, :power
+    
+    def initialize(params={})
+
+      @reload_time  = params[:reload_time]  || 10
+      @range        = params[:range]        || 10
+      @power        = params[:power]        || 1
+      
+      @reload_countdown = 0
+    end
+
+    def shoot(direction=@heading)
+      return false if reload_countdown > 0
+      @reload_countdown = @reload_time + @arena.ticks
+
+      cone = {
+        origin: @location, 
+        direction: direction, 
+        radius: @range, 
+        angle: 2
+      }
+
+      # refactor
+      possible_hits = @arena.get_all_objects.collect do |object|
+        if object[:id] != @id &&
+          hit = Helper.point_in_cone?(cone.merge(point: object[:location]))
+            object.merge(hit)
+        end
+      end.compact
+      return if possible_hits.empty?
+
+      # refactor 
+      hit = possible_hits.sort{|a,b| a[:distance] <=> b[:distance]}.first
+      @arena.forward_damage(damage: @power, target: hit[:id])
+      hit
+    end
+
+    def reload_countdown
+      return 0 if @reload_countdown <= @arena.ticks
+      @reload_countdown - @arena.ticks
+    end
+    
+  end
+end

data/lib/brawl/version.rb

@@ -1,3 +1,3 @@
 module Brawl
-  VERSION = "0.0.0.alpha"
+  VERSION = "0.0.3"
 end

data/lib/brawl/wall.rb

@@ -0,0 +1,9 @@
+module Brawl
+  
+  class Wall < BasicArenaObject
+    def damage(params={})
+      # walls can't be damaged
+    end
+  end
+  
+end

data/spec/brawl/arena_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Brawl::Arena do
+
+  let(:arena){Brawl::Arena.new(size: {width: 10, length: 10})}
+  let(:object1){Brawl::BasicArenaObject.new}
+  let(:object2){Brawl::BasicArenaobject.new}
+
+  context "when initializing" do
+    
+    it "should start the clock automatically" do
+      arena = Brawl::Arena.new(size: {width: 100, length: 100})
+      expect{sleep(0.1)}.should change(arena, :ticks)
+    end
+  end
+
+  context "when determining size" do
+
+    it "should set the size when initialized" do
+      Brawl::Arena.new(
+        size: {width: 100, length: 100}
+      ).size.should == {width: 100, length: 100}
+    end
+
+    it "should have convinence method for length" do
+      arena = Brawl::Arena.new(size: {width: 44, length: 923})
+      arena.length.should == 923
+    end
+
+    it "should have convinence method for width" do
+      arena = Brawl::Arena.new(size: {width: 234, length: 63})
+      arena.width.should == 234
+    end
+
+  end
+
+  context "when adding objects" do
+
+    it "should place an object" do
+      arena.add_object(object1).should be_true
+    end
+  
+    it "should not place objects where there is an object already" do
+      object1 = Brawl::BasicArenaObject.new(location: {x: 10, y: 10})
+      object2 = Brawl::BasicArenaObject.new(location: {x: 10, y: 10})
+      arena.add_object(object1)
+      arena.add_object(object2).should be_false
+    end
+  
+    it "should not place objects that already exist" do
+      arena.add_object(object1)
+      arena.add_object(object1).should be_false
+    end
+
+  end
+
+  context "when removing objects" do
+  
+    it "should remove an object using the object itself" do
+      arena.add_object(object1)
+      arena.remove_object(object1).should == object1
+    end
+  
+    it "should not remove objects that don't exist" do
+      arena.remove_object(object1).should be_nil
+    end
+  
+  end
+
+  context "when moving objects" do
+
+    before(:each) do
+      object1 = Brawl::BasicArenaObject.new(location: {x: 5, y: 5})
+      arena.add_object(object1)
+    end
+
+    it "should move an object from one location to another" do
+      arena.move_object(object1 => {x: 1, y: 1}).should be_true 
+    end
+
+    it "should not move an object if its already in the location" do
+      arena.move_object(object1 => {x: 5, y: 5}).should_not be_true
+    end
+  
+    it "should move an object to the correct location" do
+      arena.move_object(object1 => {x: 1, y: 1})
+      object1.location.should == {x: 1, y: 1}
+    end
+  
+    it "should not move above the bounds" do
+      # note the zero based locations
+      arena.move_object(object1 => {x: 0, y: 100}).should be_false
+    end
+  
+    it "should not move below the bounds" do
+      arena.move_object(object1 => {x: -1, y: 5}).should be_false
+    end
+    
+  end
+
+  context "when getting objects" do
+
+    it "should retrieve objects by a key and value" do
+      object1 = Brawl::BasicArenaObject.new(location: {x: 5, y: 5})
+      arena.add_object(object1)
+      arena.get_object(id: object1.id).should_not be_nil
+    end
+
+    it "should retrieve public object properties not the object itself" do
+      object1 = Brawl::BasicArenaObject.new(location: {x: 5, y: 5})
+      arena.add_object(object1)
+      arena.get_object(id: object1.id).should == object1.properties
+    end
+
+  end
+  
+  context "when pinging locations for objects" do
+
+    it "should return object information for a location" do
+      object1 = Brawl::BasicArenaObject.new(location: {x: 5, y: 5})
+      arena.add_object(object1)
+      arena.ping(x: 5, y: 5).should == object1.properties
+    end
+
+    it "should return nothing for an empty location" do
+      arena.ping(x: 5, y: 5).should be_nil
+    end
+
+    it "should return a wall for the areas around the arena" do
+      arena.ping(x:-1,y:0).select{|k,_|[:class,:location].include? k}.should ==
+        {class: Brawl::Wall, location: {x:-1, y:0}}
+    end
+
+    it "should return nothing for areas outside the wall" do
+      # note that corners can't be "seen" from inside the arena so are not walls
+      arena.ping(x:-1,y:-1).should  be_nil
+      arena.ping(x:10,y:10).should  be_nil
+      arena.ping(x:-1,y:10).should  be_nil
+      arena.ping(x:10,y:-1).should  be_nil
+      arena.ping(x:0,y:101).should  be_nil
+      arena.ping(x:11,y:0).should   be_nil
+      arena.ping(x:11,y:11).should  be_nil
+    end
+
+  end
+
+  context "when damage occurs" do
+    
+    it 'should forward damage to the damaged object' do
+      expect{arena.forward_damage(damage: 1, target: object1.id)}.should
+        change(object1, :health).by(-1)
+    end
+    
+  end
+
+  it "should set the clock to the given clock object" do
+    clock = Brawl::Clock.new
+    arena.set_clock clock
+    arena.clock.should == clock
+  end
+
+
+end

data/spec/brawl/basic_arena_object_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Brawl::BasicArenaObject do
+
+  let(:object){Brawl::BasicArenaObject.new}
+
+  it "should set a globally unique ID" do
+    object.id.should_not be_nil
+  end
+
+  it "should set a default location of {x: 0, y: 0}" do
+    object.location.should == {x: 0, y: 0}
+  end
+
+  it "should set a default heading of 0" do
+    object.heading.should == 0
+  end
+
+  it "should set a default health of 1" do
+    object.health.should == 1
+  end
+
+  it "should override a default value if a specific value is given" do
+    object = Brawl::BasicArenaObject.new(health: 20)
+    object.health.should == 20
+  end
+
+  it "should have a hash of property values" do
+    object.properties.should be_a(Hash)
+  end
+
+  it "should reduce its health based on damage received" do
+    expect{object.damage(1)}.should change(object, :health).by(-1)
+  end
+
+  it "should never reduce health to less than 0" do
+    expect{object.damage(100)}.should change(object, :health).to(0)
+  end
+
+end

data/spec/brawl/basic_bot_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Brawl::BasicBot do
+
+  let(:arena){Brawl::Arena.new(size: {width: 100, length: 100})}
+  let(:bot) {Brawl::BasicBot.new(arena: arena, location: {x: 0.0, y: 0.0})}
+
+  it "should provide a hash of 'public' properites for the arena" do
+    bot.properties.should_not be_nil
+  end
+
+  it "should have the methods of the parts that are injected into it" do
+      bot = Brawl::BasicBot.new(
+      location: {x: 0.0, y: 0.0},
+      heading: 0,
+      arena: arena,
+      parts: {Foo => {baz: "Baz set"}}
+    )
+    bot.should respond_to(:bar)
+  end
+
+  it "should access properties of the instance" do
+      bot = Brawl::BasicBot.new(
+      location: {x: 53.0, y: 34.0},
+      heading: 0,
+      arena: arena,
+      parts: {Foo => {baz: "Baz set"}}
+    )
+    bot.bar.should == {x: 53.0, y: 34.0}
+  end
+
+  it "should initialize parts" do
+      bot = Brawl::BasicBot.new(
+      location: {x: 0.0, y: 0.0},
+      heading: 0,
+      arena: arena,
+      parts: {Foo => {baz: "Baz set"}}
+    )
+    bot.baz.should == "Baz set"
+  end
+
+  it "should initialize more than one part" do
+      bot = Brawl::BasicBot.new(
+      location: {x: 0.0, y: 0.0},
+      heading: 0,
+      arena: arena,
+      parts: {Foo => {baz: "Baz set"}, Qux => {quux: "Quux set"}}
+    )
+    bot.quux.should == "Quux set"
+  end
+
+  it "should have methods of more than one part" do
+      bot = Brawl::BasicBot.new(
+      location: {x: 11.0, y: 222.0},
+      heading: 0,
+      arena: arena,
+      parts: {Foo => {baz: "Baz set"}, Qux => {quux: "Quux set"}}
+    )
+    bot.phoo.should == {x: 11.0, y: 222.0}
+  end
+
+end
+
+module Foo
+  attr_accessor :baz
+  def initialize(params={})
+    @baz = params[:baz]
+  end
+  def bar
+    @location
+  end
+end
+
+module Qux
+  attr_accessor :quux
+  def initialize(params={})
+    @quux = params[:quux]
+  end
+  def phoo
+    @location
+  end
+end
+
+