rtanque 0.0.2

data/sample_bots/seek_and_destroy.rb

@@ -0,0 +1,51 @@
+# Seek&Destroy: Sample Bot
+#
+# Enjoys following and target and firing many shots
+class SeekAndDestroy < RTanque::Bot::Brain
+  NAME = 'Seek&Destroy'
+  include RTanque::Bot::BrainHelper
+
+  TURRET_FIRE_RANGE = RTanque::Heading::ONE_DEGREE * 5.0
+
+  def tick!
+    if (lock = self.get_radar_lock)
+      self.destroy_lock(lock)
+      @desired_heading = nil
+    else
+      self.seek_lock
+    end
+  end
+
+  def destroy_lock(reflection)
+    command.heading = reflection.heading
+    command.radar_heading = reflection.heading
+    command.turret_heading = reflection.heading
+    command.speed = reflection.distance > 200 ? MAX_BOT_SPEED : MAX_BOT_SPEED / 2.0
+    if (reflection.heading.delta(sensors.turret_heading)).abs < TURRET_FIRE_RANGE
+      command.fire(reflection.distance > 200 ? MAX_FIRE_POWER : MIN_FIRE_POWER)
+    end
+  end
+
+  def seek_lock
+    if sensors.position.on_wall?
+      @desired_heading = sensors.heading + RTanque::Heading::HALF_ANGLE
+    end
+    command.radar_heading = sensors.radar_heading + MAX_RADAR_ROTATION
+    command.speed = 1
+    if @desired_heading
+      command.heading = @desired_heading
+      command.turret_heading = @desired_heading
+    end
+  end
+
+  def get_radar_lock
+    @locked_on ||= nil
+    lock = if @locked_on
+      sensors.radar.find { |reflection| reflection.name == @locked_on } || sensors.radar.first
+    else
+      sensors.radar.first
+    end
+    @locked_on = lock.name if lock
+    lock
+  end
+end

data/spec/rtanque/bot_spec.rb

@@ -0,0 +1,239 @@
+require "spec_helper"
+
+describe RTanque::Bot do
+  before(:each) { @brain_tick_lambda = lambda { } }
+  let(:bot){ brain_bot(&@brain_tick_lambda) }
+
+  context '#dead?' do
+    it 'should not initially be dead' do
+      expect(bot.dead?).to be_false
+    end
+
+    it 'should be true if health is below min' do
+      bot.health = RTanque::Configuration.bot.health.min - 1
+      expect(bot.dead?).to be_true
+    end
+  end
+
+  context '#sensors' do
+    it 'should return a Sensors instance' do
+      expect(bot.sensors).to be_instance_of RTanque::Bot::Sensors
+    end
+
+    it 'should correctly transfer values from bot' do
+      bot.health = 5
+      bot.speed = -2
+      expect(bot.sensors.health).to eq 5
+      expect(bot.sensors.speed).to eq -2
+    end
+  end
+
+  context '#tick' do
+    context 'no commands' do
+      it 'should not update bot position, heading on tick' do
+        bot.tick
+        expect(bot.position.x).to eq 0.0
+        expect(bot.position.y).to eq 0.0
+        expect(bot.heading).to eq 0
+      end
+    end
+
+    context 'command with speed' do
+      before(:each) do
+        bot.speed = 1
+        bot.heading = 0
+      end
+
+      it 'should update bot position on tick' do
+        bot.tick
+        expect(bot.position.x).to eq 0.0
+        expect(bot.position.y).to eq 1.0
+      end
+
+      it 'should keep updating bot position' do
+        5.times { bot.tick }
+        expect(bot.position.x).to eq 0.0
+        expect(bot.position.y).to eq 5.0
+      end
+
+      it 'should stop at arena limit' do
+        (@arena.height + 2).times { bot.tick }
+        expect(bot.position.x).to eq 0.0
+        expect(bot.position.y).to eq @arena.height
+      end
+    end
+
+    context 'command with heading' do
+      before(:each) do
+        bot.heading = RTanque::Heading::EAST
+      end
+
+      it 'should have heading east' do
+        bot.tick
+        expect(bot.heading).to eq RTanque::Heading::EAST
+      end
+
+      it 'should keep heading east' do
+        5.times { bot.tick }
+        expect(bot.heading).to eq RTanque::Heading::EAST
+      end
+
+      it 'should maintain heading given null heading' do
+        bot.tick
+        @brain_tick_lambda = lambda { command.heading = nil }
+        expect(bot.heading).to eq RTanque::Heading::EAST
+      end
+
+      it 'should not change radar and turret headings' do
+        bot.tick
+        expect(bot.radar.heading).to eq 0.0
+        expect(bot.turret.heading).to eq 0.0
+      end
+    end
+
+    context 'radar heading' do
+      before(:each) do
+        bot.radar.heading = RTanque::Heading::EAST
+        bot.tick
+      end
+
+      it 'should change radar heading' do
+        expect(bot.radar.heading).to eq RTanque::Heading::EAST
+      end
+
+      it 'should not change bot heading' do
+        expect(bot.heading).to eq 0
+      end
+    end
+
+    context 'turret heading' do
+      before(:each) do
+        bot.turret.heading = RTanque::Heading::EAST
+        bot.tick
+      end
+
+      it 'should change radar heading' do
+        expect(bot.turret.heading).to eq RTanque::Heading::EAST
+      end
+
+      it 'should not change bot heading' do
+        expect(bot.heading).to eq 0
+      end
+    end
+
+    context 'fire power' do
+      it 'bot should have 0 fire_power' do
+        bot.tick
+        expect(bot.fire_power).to eq 0
+      end
+
+      it 'bot should have fire_power reset' do
+        bot.fire_power = 1
+        bot.tick
+        expect(bot.fire_power).to eq 0
+      end
+    end
+
+    context 'command with error' do
+      before(:each) do
+        @brain_tick_lambda = lambda { raise 'oops' }
+      end
+
+      it 'should capture error' do
+        expect{ bot.tick }.not_to raise_exception
+      end
+
+      it 'should reduce bot health' do
+        original_health = bot.health
+        bot.tick
+        expect(bot.health).to be < original_health
+      end
+    end
+  end
+
+  context 'bot command speed' do
+    before(:each) do
+      @brain_tick_lambda = lambda { command.speed = RTanque::Bot::MAX_SPEED + 1 }
+      bot.tick
+    end
+
+    it 'should respect step size' do
+      expect(bot.speed).to eq RTanque::Configuration.bot.speed_step
+    end
+
+    it 'should respect max speed' do
+      times = RTanque::Bot::MAX_SPEED / RTanque::Configuration.bot.speed_step
+      (times + 1).to_i.times { bot.tick }
+      expect(bot.speed).to eq RTanque::Bot::MAX_SPEED
+    end
+
+    it 'should respect min speed' do
+      @brain_tick_lambda = lambda { command.speed = -(RTanque::Bot::MAX_SPEED + 1) }
+      times = RTanque::Bot::MAX_SPEED / RTanque::Configuration.bot.speed_step
+      (times + 1).to_i.times { bot.tick }
+      expect(bot.speed).to eq RTanque::Bot::MAX_SPEED
+    end
+  end
+
+  context 'bot command heading' do
+    it 'should respect step size' do
+      @brain_tick_lambda = lambda { command.heading = RTanque::Heading::S }
+      bot.tick
+      expect(bot.heading).to eq RTanque::Heading.new(RTanque::Configuration.bot.turn_step)
+    end
+
+    it 'should respect step size in negative' do
+      @brain_tick_lambda = lambda { command.heading = -RTanque::Heading::S }
+      bot.tick
+      expect(bot.heading).to eq RTanque::Heading.new(-RTanque::Configuration.bot.turn_step)
+    end
+  end
+
+  context 'bot command radar heading' do
+    it 'should respect step size' do
+      @brain_tick_lambda = lambda { command.radar_heading = RTanque::Heading::S }
+      bot.tick
+      expect(bot.radar.heading).to eq RTanque::Heading.new(RTanque::Configuration.radar.turn_step)
+    end
+
+    it 'should respect step size in negative' do
+      @brain_tick_lambda = lambda { command.radar_heading = -RTanque::Heading::S }
+      bot.tick
+      expect(bot.radar.heading).to eq RTanque::Heading.new(-RTanque::Configuration.radar.turn_step)
+    end
+  end
+
+  context 'bot command turret heading' do
+    it 'should respect step size' do
+      @brain_tick_lambda = lambda { self.command.turret_heading = RTanque::Heading::S }
+      bot.tick
+      expect(bot.turret.heading).to eq RTanque::Heading.new(RTanque::Configuration.turret.turn_step)
+    end
+
+    it 'should respect step size in negative' do
+      @brain_tick_lambda = lambda { self.command.turret_heading = -RTanque::Heading::S }
+      bot.tick
+      expect(bot.turret.heading).to eq RTanque::Heading.new(-RTanque::Configuration.turret.turn_step)
+    end
+  end
+
+  context 'bot command fire_power' do
+    it 'should respect max' do
+      @brain_tick_lambda = lambda { command.fire_power = RTanque::Bot::MAX_FIRE_POWER + 1 }
+      bot.tick
+      expect(bot.fire_power).to eq RTanque::Bot::MAX_FIRE_POWER
+    end
+
+    it 'should respect min' do
+      @brain_tick_lambda = lambda { command.fire_power = RTanque::Bot::MIN_FIRE_POWER - 1 }
+      bot.tick
+      expect(bot.fire_power).to eq RTanque::Bot::MIN_FIRE_POWER
+    end
+
+    it 'should not allow constant shooting' do
+      @brain_tick_lambda = lambda { command.fire_power = RTanque::Bot::MAX_FIRE_POWER }
+      5.times { bot.tick }
+      expect(bot.fire_power).not_to eq RTanque::Bot::MAX_FIRE_POWER
+    end
+  end
+end

data/spec/rtanque/heading_spec.rb

@@ -0,0 +1,279 @@
+require "spec_helper"
+
+describe RTanque::Heading do
+  NINETY = Math::PI / 2.0
+
+  describe '#delta' do
+    before do
+      @instance = described_class.new(0)
+    end
+
+    it 'receives floats' do
+      other = 0.0
+      expect(@instance.delta(other)).to eql 0.0
+    end
+
+    it 'receives headings' do
+      other = described_class.new(0.0)
+      expect(@instance.delta(other)).to eql 0.0
+    end
+
+    it 'gives 0 when provided same a == b' do
+      expect(@instance.delta(@instance)).to eq 0
+    end
+
+    it 'outputs positive when a < b' do
+      expect(@instance.delta(@instance + 1)).to be > 0
+    end
+
+    it 'outputs negative when b < a' do
+      expect(@instance.delta(@instance - 1)).to be < 0
+    end
+
+    it 'correct output when difference < 180 deg' do
+      expect(@instance.delta(NINETY)).to eq NINETY
+    end
+
+    it 'correct output when difference > 180 deg' do
+      expect(@instance.delta(NINETY * 3)).to eq -NINETY
+    end
+
+    it 'correctly handles degress > 360' do
+      expect(@instance.delta(NINETY * 5)).to eq NINETY
+    end
+
+    it 'correctly handles differences > 180 in which a < b' do
+      expect(@instance.delta(NINETY * 3)).to eq -NINETY
+    end
+
+    it 'correctly handles differences > 180 in which a > b' do
+      expect(@instance.delta(-(NINETY * 3))).to eq NINETY
+    end
+
+    it 'correctly handles when a and b are on both sides of 180' do
+      @instance = described_class.new(RTanque::Heading::S - RTanque::Heading::ONE_DEGREE)
+      delta = RTanque.round(@instance.delta(RTanque::Heading::S + RTanque::Heading::ONE_DEGREE), 5)
+      expected = RTanque.round(RTanque::Heading::ONE_DEGREE * 2, 5)
+      expect(delta).to eq(expected)
+    end
+  end
+
+  describe '.new_from_degrees' do
+    it 'receives positive degrees' do
+      expect(described_class.new_from_degrees(90).to_f).to eql NINETY
+    end
+
+    it 'receives degrees large than 360' do
+      expect(described_class.new_from_degrees(90 + 360).to_f).to eql NINETY
+    end
+
+    it 'receives negative degrees' do
+      expect(described_class.new_from_degrees(-90).to_f).to eql NINETY * 3
+    end
+
+    it 'receives negative degrees less than -360' do
+      expect(described_class.new_from_degrees(-90 - 360).to_f).to eql NINETY * 3
+    end
+  end
+
+  describe '.delta_between_points' do
+    let(:from_point) { RTanque::Point.new(10, 10, @arena) }
+    let(:from_heading) { described_class.new(0) }
+    it 'is correct when 0 delta' do
+      to_point = RTanque::Point.new(10, 20, @arena)
+      expect(described_class.delta_between_points(from_point, from_heading, to_point)).to eq 0
+    end
+
+    it 'is correct when delta is negative' do
+      to_point = RTanque::Point.new(9, 11)
+      expect(described_class.delta_between_points(from_point, from_heading, to_point)).to eq -(NINETY / 2)
+    end
+
+    it 'is correct when delta is positive' do
+      to_point = RTanque::Point.new(11, 11)
+      expect(described_class.delta_between_points(from_point, from_heading, to_point)).to eq(NINETY / 2)
+    end
+
+    it 'is correct when delta is max' do
+      to_point = RTanque::Point.new(10, 9)
+      expect(described_class.delta_between_points(from_point, from_heading, to_point)).to eq(NINETY * 2)
+    end
+  end
+
+  describe '#initialize' do
+    it 'receives inits and sets radians to float' do
+      expect(described_class.new(0).radians).to eql 0.0
+    end
+
+    it 'receives negative floats' do
+      expect(described_class.new(-NINETY).radians).to eql NINETY * 3
+    end
+
+    it 'creates frozen object' do
+      expect(described_class.new(0).frozen?).to be_true
+    end
+  end
+
+  describe '#clone' do
+    it 'returns a Heading' do
+      expect(described_class.new.clone).to be_instance_of described_class
+    end
+
+    it 'returns a new object' do
+      original = described_class.new
+      copy = original.clone
+      expect(original.object_id).not_to eq copy.object_id
+    end
+
+    it 'returns a new object which does not affect old' do
+      original = described_class.new(0.0)
+      copy = original.clone
+      expect(copy).not_to equal original
+    end
+  end
+
+  describe '#==' do
+    it 'works like Numeric, ignoring type' do
+      a = described_class.new(1.0)
+      expect(a == 1).to be_true
+    end
+
+    it 'correctly compares two equal headings' do
+      a = described_class.new(1.0)
+      b = described_class.new(1.0)
+      expect(a == b).to be_true
+    end
+
+    it 'correctly compares two different headings' do
+      a = described_class.new(0)
+      b = described_class.new(1.0)
+      expect(a == b).to be_false
+    end
+
+    it 'compares to a numeric on LHS' do
+      a = described_class.new(Math::PI)
+      expect(Math::PI == a).to be_true
+    end
+  end
+
+  describe '#eql?' do
+    it 'compares types like Numeric, comparing type' do
+      a = described_class.new(1.0)
+      expect(a.eql?(1)).to be_false
+    end
+
+    it 'correctly compares two equal headings' do
+      a = described_class.new(1.0)
+      b = described_class.new(1.0)
+      expect(a.eql?(b)).to be_true
+    end
+
+    it 'correctly compares two different headings' do
+      a = described_class.new(0)
+      b = described_class.new(1.0)
+      expect(a.eql?(b)).to be_false
+    end
+  end
+
+  describe '#<=>' do
+    it 'receives headings' do
+      a = described_class.new
+      b = described_class.new(NINETY)
+      expect(a <=> b).to eq -1
+    end
+
+    it 'receives floats' do
+      a = described_class.new
+      expect(a <=> NINETY).to eq -1
+    end
+  end
+
+  describe '#+' do
+    it 'returns new instance' do
+      a = described_class.new(0.0)
+      result = a + NINETY
+      expect(result).not_to eql a
+      expect(result).not_to equal a
+      expect(result).to be_kind_of described_class
+    end
+
+    it 'leaves receiver unchanged' do
+      a = described_class.new(1.0)
+      a + NINETY
+      expect(a).to eql described_class.new(1.0)
+    end
+
+    it 'correctly adds' do
+      a = described_class.new(0.0) + NINETY
+      expect(a).to eq NINETY
+    end
+
+    it 'correctly adds negative numbers' do
+      a = described_class.new(0.0) + -NINETY
+      expect(a).to eq(NINETY * 3)
+    end
+
+    it 'correctly adds other headings' do
+      a = described_class.new(NINETY * 2)
+      b = described_class.new(NINETY)
+      expect(a + b).to eq(NINETY * 3)
+    end
+
+    it 'respects radian module ring' do
+      a = described_class.new(NINETY * 3)
+      b = described_class.new(NINETY * 3)
+      expect(a + b).to eq NINETY * 2
+    end
+  end
+
+  describe '#*' do
+    it 'returns new instance' do
+      a = described_class.new(NINETY)
+      result = a * NINETY
+      expect(result).not_to eql a
+      expect(result).not_to equal a
+      expect(result).to be_kind_of described_class
+    end
+
+    it 'correctly multiplies' do
+      a = described_class.new(NINETY)
+      expect(a * 2.0).to eq NINETY * 2.0
+    end
+  end
+
+  describe '#/' do
+    it 'returns new instance' do
+      a = described_class.new(NINETY)
+      result = a / NINETY
+      expect(result).not_to eql a
+      expect(result).not_to equal a
+      expect(result).to be_kind_of described_class
+    end
+
+    it 'correctly divides' do
+      a = described_class.new(NINETY * 2.0)
+      expect(a / 2.0).to eq NINETY
+    end
+  end
+
+  describe '#-@' do
+    it 'creates a new instance' do
+      a = described_class.new(1.0)
+      b = -a
+      expect(b).not_to equal a
+    end
+
+    it 'correctly negates itself' do
+      expect(-described_class.new(NINETY)).to eq(NINETY * 3)
+    end
+  end
+
+  describe '#to_degrees' do
+    it 'returns float' do
+      a = described_class.new
+      expect(a.to_degrees).to eq 0.0
+      b = described_class.new(NINETY)
+      expect(b.to_degrees).to eq 90.0
+    end
+  end
+end