brawl 0.0.0.alpha → 0.0.3

data/spec/brawl/battle_controller_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+$DEBUG=true
+Thread.abort_on_exception
+
+describe Brawl::BattleController do
+
+  let(:arena_data) {{size: {width: 10, length: 10}}}
+  let(:clock_data) {{tick_rate: 0.01}}
+
+  let(:motor)   { {Brawl::BasicMotor=>{move_max: 1, turn_max: 360}} }
+  let(:scanner) { {Brawl::BasicScanner=>{scan_max: 30, angle_max: 360}} }
+  let(:weapon)  { {Brawl::BasicWeapon=>{range: 20, power: 1}} }
+  let(:parts)   {  motor.merge(scanner).merge(weapon) }
+
+  let(:bot_code) do
+    <<-CODE
+    code do |bot|
+      # puts
+      # puts "Basic bot... meh."
+      if rand(0) > 0.5
+        bot.turn [:left,:right,:around].sample
+      end
+      bot.move rand(3) + 1
+    end
+    CODE
+  end
+  let(:bot1) do
+    {
+      name: "Basic Bot 1",
+      class: Brawl::BasicBot,
+      params: {parts: parts},
+      code: bot_code
+    }
+  end
+
+
+  let(:helpless_bot_code) do
+    <<-CODE
+    code do |bot|
+      sleep(0.05)
+    end
+    CODE
+  end
+  let(:helpless_bot1) do
+    {
+      name: "Helpless Bot 1",
+      class: Brawl::BasicBot,
+      params: {parts: parts},
+      code: helpless_bot_code
+    }
+  end
+
+  let(:battle_bot_code) do
+    <<-CODE
+    code do |bot|
+      @dir ||= 0
+      # puts
+      # puts "Battle Bot!"
+      # puts "scan: \#{@dir}"
+      targets = bot.scan direction: @dir, angle: 90
+      @dir += 45
+      @dir %= 360
+      targets.each do |target|
+        unless target[:class] == Brawl::Wall
+          # puts "  target: \#{target[:name]}"
+          # puts " bearing: \#{target[:bearing]}"
+          # puts "distance: \#{target[:distance]}"
+          results = shoot(target[:bearing])
+          # puts "shoot results: \#{results}"
+        end
+      end
+    end
+    CODE
+  end
+  let(:battle_bot1) do
+    {
+      name: "Battle Bot 1",
+      class: Brawl::BasicBot,
+      params: {parts: parts},
+      code: battle_bot_code
+    }
+  end
+
+  context "when configuring the controller" do
+
+    it "should create an arena object" do
+      battle = Brawl::BattleController.new
+      battle.make_arena(arena_data)
+      battle.arena.should be_a(Brawl::Arena)
+    end
+
+    it "should create a clock object" do
+      battle = Brawl::BattleController.new
+      battle.make_clock(clock_data)
+      battle.clock.should be_a(Brawl::Clock)
+    end
+
+    it "should set the arena's clock to the created clock" do
+      battle = Brawl::BattleController.new
+      battle.make_arena(arena_data)
+      battle.make_clock(clock_data)
+      battle.arena.clock.should == battle.clock
+    end
+
+    it "should create bots" do
+      battle = Brawl::BattleController.new
+      battle.make_arena(arena_data)
+      battle.make_clock(clock_data)
+
+      bot_data = [bot1]
+      battle.make_bots(bot_data)
+
+      battle.bots.should_not be_empty
+    end
+
+  end
+
+  context "when running bots" do
+
+    it "should stop when one bot reaches 0 health" do
+      battle = Brawl::BattleController.new
+      battle.make_arena(arena_data)
+      battle.make_clock(clock_data)
+
+      bot_data = [helpless_bot1, battle_bot1]
+      battle.make_bots(bot_data)
+      # puts "victory? #{battle.victory?}"
+      battle.start
+      until battle.victory?
+        sleep(0.5)
+      end
+      battle.victory?.should be_true
+      # puts "victory? #{battle.victory?}"
+    end
+
+  end
+
+end

data/spec/brawl/clock_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Brawl::Clock do
+
+  let(:clock){Brawl::Clock.new(0.01)}
+
+  it "should start counting" do
+    expect{clock.start; sleep(0.05)}.should change(clock, :ticks)
+    clock.stop
+  end
+
+  it "should stop counting" do
+    clock.start
+    sleep(0.02)
+    clock.stop
+    sleep(0.02)
+    expect{sleep(0.05)}.should_not change(clock, :ticks)
+  end
+
+  it "should increment 'tick' at the specified interval" do
+    clock = Brawl::Clock.new(0.01)
+    clock.start
+    sleep(0.10)
+    clock.stop
+    clock.ticks.should be_within(1.1).of(10)
+  end
+
+end

data/spec/brawl/helper_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Brawl::Helper do
+
+  let(:helper){Brawl::Helper}
+
+  context "when wrapping angles" do
+
+    # no change
+    it {helper.wrap_angle(45).should == 45.0}
+    it {helper.wrap_angle(179).should == 179.0 }
+    it {helper.wrap_angle(-40).should == -40.0}
+    it {helper.wrap_angle(-179).should == -179.0 }
+
+    # complement angle, "Have you been working out? You look less obtuse!"
+    it {helper.wrap_angle(270).should == -90.0 }
+    it {helper.wrap_angle(-320).should == 40.0 }
+    it {helper.wrap_angle(-280).should == 80.0 }
+    it {helper.wrap_angle(185).should == -175.0 }
+
+  end
+
+end

data/spec/brawl/parts/basic_motor_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe Brawl::BasicMotor do
+
+  let(:arena){Brawl::Arena.new(size: {width: 100, length: 100})}
+  let(:bot) do 
+    Brawl::BasicBot.new(
+      arena: arena, 
+      parts: {Brawl::BasicMotor=>{move_max: 1, turn_max: 360}}
+    )
+  end
+
+  context "when moving" do
+
+    it "should move forward one space" do
+      expect{bot.move 1}.should change(bot, :location).
+       from({x: 0.0, y: 0.0}).
+       to({x: 0.0, y: 1.0})
+    end
+    
+    it "should move forward one space" do
+      bot.turn :right
+      
+      expect{bot.move}.should change(bot, :location).
+       from({x: 0.0, y: 0.0}).
+       to({x: 1.0, y: 0.0})
+    end
+    
+    it "should move in the direction it is facing" do
+      bot.turn to_angle: 45
+      expect{bot.move}.should change(bot, :location).
+       from({x: 0.0, y: 0.0}).
+       to({x: 0.7, y: 0.7})
+    end
+
+    it "should not move more than the maximum allowed" do
+      expect{bot.move 5}.should change(bot, :location).
+       from({x: 0.0, y: 0.0}).
+       to({x: 0.0, y: 1.0})
+    end
+
+    it "should not move into walls" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 0, y:99},
+        parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 360}}
+      )
+      expect{bot.move}.should_not change(bot, :location)
+    end
+
+    it "should move in reverse" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 50, y:50},
+        parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 360}}
+      )
+      expect{bot.move -1}.should change(bot, :location).
+       from({x: 50.0, y: 50.0}).
+       to({x: 50.0, y: 49.0})
+    end
+
+    it "should not move in reverse more than the maximum allowed" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 50, y:50},
+        parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 360}}
+      )
+      expect{bot.move -5}.should change(bot, :location).
+       from({x: 50.0, y: 50.0}).
+       to({x: 50.0, y: 47.0})
+    end
+
+
+  end
+
+  context "when turning" do
+
+    context "and given an angle" do
+
+      it "should 'wrap-around' degrees given" do
+        expect{bot.turn to_angle: 390}.should change(bot, :heading).
+          from(0).
+          to(30)
+      end
+
+      it "should turn by negative degrees" do
+        expect{bot.turn to_angle: -90}.should change(bot, :heading).
+          from(0).
+          to(270)
+      end
+
+      it "should turn to a positive angle within its maximum turn rate" do
+        bot = Brawl::BasicBot.new(
+          arena: arena, 
+          parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 90}}
+        )
+        bot.turn to_angle: 40
+        expect{bot.turn to_angle: 320}.should change(bot, :heading).
+          from(40).
+          to(320)
+      end
+
+      it "should turn by negative degrees within its maximum turn rate" do
+        bot = Brawl::BasicBot.new(
+          arena: arena, 
+          parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 90}}
+        )
+        bot.turn to_angle: 40
+        expect{bot.turn to_angle: -40}.should change(bot, :heading).
+          from(40).
+          to(320)
+      end
+
+      it "should not turn more than its maximum turn rate" do
+        bot = Brawl::BasicBot.new(
+          arena: arena, 
+          parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 90}}
+        )
+        expect{bot.turn to_angle: 91}.should change(bot, :heading).
+          from(0).
+          to(90)
+      end
+
+      it "should not turn more than its maximum turn rate counter-clockwise" do
+        bot = Brawl::BasicBot.new(
+          arena: arena, 
+          parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 90}}
+        )
+        expect{bot.turn to_angle: -91}.should change(bot, :heading).
+          from(0).
+          to(270)
+      end
+
+
+    end
+
+    context "and given degrees" do
+      
+      it "should turn to the angle specified" do
+        expect{bot.turn to_angle: 45}.should change(bot, :heading).
+          from(0).
+          to(45)
+      end
+    
+      it "should turn in the direction specified" do
+        bot.turn to_angle: 45
+        expect{bot.turn by_degrees: 45}.should change(bot, :heading).
+          from(45).
+          to(90)
+      end
+    
+      it "should convert heading 360 to 0" do
+        bot.turn to_angle: 359
+        expect{bot.turn by_degrees: 1}.should change(bot, :heading).
+          from(359).
+          to(0)
+      end
+
+      it "should 'wrap-around' degrees" do
+        bot.turn to_angle: 300
+        expect{bot.turn by_degrees: 90}.should change(bot, :heading).
+          from(300).
+          to(30)
+      end
+
+      it "should 'wrap-around' degrees larger than 360" do
+        expect{bot.turn by_degrees: 390}.should change(bot, :heading).
+          from(0).
+          to(30)
+      end
+
+     it "should turn using negative degrees" do
+       bot = Brawl::BasicBot.new(
+         arena: arena, 
+         parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 90}}
+       )
+       
+       bot.turn to_angle: 20
+       expect{bot.turn by_degrees: -40}.should change(bot, :heading).
+         from(20).
+         to(340)
+     end
+
+      it "should not turn more than its maximum turn rate" do
+        bot = Brawl::BasicBot.new(
+          arena: arena, 
+          parts: {Brawl::BasicMotor=>{move_max: 3, turn_max: 90}}
+        )
+        expect{bot.turn by_degrees: 91}.should change(bot, :heading).
+          from(0).
+          to(90)
+      end
+
+    end
+
+    context "and given a direction name" do
+      
+      it "should turn left" do
+        expect{bot.turn :left}.should change(bot, :heading).
+          from(0).
+          to(270)
+      end
+
+      it "should turn right" do
+        expect{bot.turn :right}.should change(bot, :heading).
+          from(0).
+          to(90)
+      end
+
+      it "should turn around" do
+        expect{bot.turn :around}.should change(bot, :heading).
+          from(0).
+          to(180)
+      end
+      
+    end
+    
+  end
+
+end

data/spec/brawl/parts/basic_scanner_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Brawl::BasicScanner do
+
+  let(:arena){Brawl::Arena.new(size: {width: 10, length: 10})}
+  let(:bot) do 
+    Brawl::BasicBot.new(
+      arena: arena, 
+      parts: {Brawl::BasicScanner=>{scan_max: 10, angle_max: 90}}
+    )
+  end
+
+  it "should set its maximum scan distance initialized" do
+    bot.scan_max.should == 10
+  end 
+
+  it "should set its maximum scan angle initialized" do
+    bot.angle_max.should == 90
+  end 
+
+  context "when scanning" do
+
+    it "should return an empty array of contacts if nothing is in range" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 5},
+        parts: {Brawl::BasicScanner=>{scan_max: 1, angle_max: 90}}
+      )
+      bot.scan(direction: 0, angle: 1).should be_empty
+    end
+
+    it "should find walls if in range" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 5},
+        parts: {Brawl::BasicScanner=>{scan_max: 5, angle_max: 180}}
+      )
+      bot.scan(direction: 0, angle: 1).should_not be_empty
+    end
+
+    it "should find enemies if in range" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 5},
+        parts: {Brawl::BasicScanner=>{scan_max: 1, angle_max: 180}}
+      )
+      enemy = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 6},
+        parts: {Brawl::BasicScanner=>{scan_max: 1, angle_max: 180}}
+      )
+      scan = bot.scan(direction: 0, angle: 1)
+      scan.any?{|contact| contact[:id] = enemy.id}
+    end 
+
+    it "should not find enemies if out of range" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 5},
+        parts: {Brawl::BasicScanner=>{scan_max: 1, angle_max: 180}}
+      )
+      enemy = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 7},
+        parts: {Brawl::BasicScanner=>{scan_max: 1, angle_max: 180}}
+      )
+      bot.scan(direction: 0, angle: 1).should be_empty
+    end  
+    
+    it "should find enemies to the side with a wide scan" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 5},
+        parts: {Brawl::BasicScanner=>{scan_max: 3, angle_max: 180}}
+      )
+      enemy = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 5, y: 7},
+        parts: {Brawl::BasicScanner=>{scan_max: 10, angle_max: 180}}
+      )
+      scan = bot.scan(direction: 0, angle: 180)
+      scan.any?{|contact| contact[:id] = enemy.id}
+    end
+
+    it "should find enemies to the side with a wide scan" do
+      bot = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 0, y: 0},
+        parts: {Brawl::BasicScanner=>{scan_max: 10, angle_max: 180}}
+      )
+      enemy = Brawl::BasicBot.new(
+        arena: arena,
+        location: {x: 7, y: 7},
+        parts: {Brawl::BasicScanner=>{scan_max: 10, angle_max: 180}}
+      )
+      scan = bot.scan(direction: 0, angle: 180)
+      scan.any?{|contact| contact[:id] = enemy.id}
+    end  
+  end
+
+end