rtanque 0.0.2

data/spec/rtanque/match_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe RTanque::Match do
+  before do
+    @instance = described_class.new(@arena)
+  end
+
+  it 'should start with 0 ticks' do
+    expect(@instance.ticks).to eql 0
+  end
+
+  it 'should allow adding bots' do
+    bot = double('bot')
+    @instance.add_bots(bot)
+    expect(@instance.bots.include?(bot)).to be_true
+  end
+
+  describe '#finished?' do
+    it 'should be true if one or less bots left' do
+      expect(@instance.finished?).to be_true
+    end
+
+    it 'should be false if two or more bots left' do
+      @instance.add_bots(:bot, :bot2)
+      expect(@instance.finished?).to be_false
+    end
+  end
+
+  describe '#tick' do
+    it 'should increment tick count' do
+      @instance.tick
+      expect(@instance.ticks).to eq 1
+    end
+  end
+
+end

data/spec/rtanque/normalized_attr_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+INFINITY = 1.0 / 0.0
+
+describe RTanque::NormalizedAttr do
+  context 'integer range, no max delta' do
+    let(:instance) do
+      described_class::AttrContainer.new(1..5)
+    end
+    let(:attached_instance) do
+      mock('some_object')
+    end
+
+    it 'has -infinity as max_delta' do
+      expect(instance.max_delta(attached_instance)).to eq INFINITY
+    end
+
+    it 'has correct delta' do
+      expect(instance.delta(nil, 100)).to eq 0
+    end
+
+    it 'does not allow more than range' do
+      expect(instance.normalize(attached_instance, nil, 100)).to eq 5
+    end
+
+    it 'does not allow less than range' do
+      expect(instance.normalize(attached_instance, nil, -100)).to eq 1
+    end
+  end
+
+  context 'integer range, max delta' do
+    let(:instance) do
+      described_class::AttrContainer.new(0..5, lambda{ |attached| attached.max_delta })
+    end
+    let(:attached_instance) do
+      mock('some_object', :max_delta => 0.1)
+    end
+
+    it 'should call block for max_delta' do
+      attached = mock('some_object')
+      attached.should_receive(:max_delta).and_return(0.1)
+      expect(instance.max_delta(attached)).to eq 0.1
+    end
+
+    it 'does not allow a change greater than given delta' do
+      expect(instance.normalize(attached_instance, 1, 2)).to eq 1.1
+    end
+
+    it 'does not allow a change less than given delta' do
+      expect(instance.normalize(attached_instance, 2, 1)).to eq 1.9
+    end
+  end
+
+  #context 'heading range' do
+  #  let(:normalized) do
+  #    described_class::AttrContainer.new(0..RTanque::Heading::FULL_ANGLE, RTanque::Heading::ONE_DEGREE)
+  #  end
+  #
+  #  it 'should respect step' do
+  #    expect(normalized.normalize(Math::PI, 0)).to eq RTanque::Heading::ONE_DEGREE
+  #  end
+  #
+  #  it 'should allow full 360 turn' do
+  #    previous = 0
+  #    360.times do
+  #      new_value = normalized.normalize(previous + Math::PI, previous)
+  #      expect(new_value).to eq(RTanque::Heading.new(previous) + RTanque::Heading::ONE_DEGREE)
+  #      previous = new_value
+  #    end
+  #  end
+  #end
+  #
+  #context 'mixin' do
+  #  class Tester
+  #    extend RTanque::NormalizedAttr
+  #    attr_accessor :speed
+  #    attr_normalized :speed, 0..5
+  #  end
+  #
+  #  it 'defines normalize method' do
+  #    expect(Tester.instance_methods.grep(/normalized_speed/)).to have(1).match
+  #  end
+  #
+  #  it 'normalize method behaves correctly' do
+  #    i = Tester.new
+  #    expect(i.normalized_speed(100)).to eq 5
+  #  end
+  #
+  #end
+end

data/spec/rtanque/point_spec.rb

@@ -0,0 +1,196 @@
+require "spec_helper"
+
+describe RTanque::Point do
+  context '.distance' do
+    it 'gives 0 when points are equal' do
+      a = described_class.new(0, 0, @arena)
+      b = described_class.new(0, 0, @arena)
+      expect(described_class.distance(a,b)).to eq 0
+    end
+
+    it 'always returns positive number' do
+      a = described_class.new(0, 0, @arena)
+      b = described_class.new(10, 0, @arena)
+      expect(described_class.distance(a, b)).to eq 10
+      expect(described_class.distance(b, a)).to eq 10
+    end
+  end
+
+  context '#initialize' do
+    it 'should be frozen' do
+      a = described_class.new(10, 10, @arena)
+      expect(a.frozen?).to be_true
+    end
+
+    it 'should not allow modification' do
+      a = described_class.new(10, 10, @arena)
+      expect { a.x = 1 }.to raise_exception(RUBY_VERSION >= '1.9' ? RuntimeError : TypeError)
+    end
+  end
+
+  context '#heading' do
+    before do
+      @instance = described_class.new(5, 5, @arena)
+    end
+
+    it 'return correct heading when at 0deg' do
+      other = described_class.new(5, 10, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::N
+    end
+
+    it 'return correct heading when at 45deg' do
+      other = described_class.new(10, 10, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::NE
+    end
+
+    it 'return correct heading when at 90deg' do
+      other = described_class.new(10, 5, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::E
+    end
+
+    it 'return correct heading when at 135deg' do
+      other = described_class.new(10, 0, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::SE
+    end
+
+    it 'return correct heading when at 180deg' do
+      other = described_class.new(5, 0, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::S
+    end
+
+    it 'return correct heading when at 225deg' do
+      other = described_class.new(0, 0, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::SW
+    end
+
+    it 'return correct heading when at 270deg' do
+      other = described_class.new(0, 5, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::W
+    end
+
+    it 'return correct heading when at 315deg' do
+      other = described_class.new(0, 10, @arena)
+      expect(@instance.heading(other)).to eq RTanque::Heading::NW
+    end
+
+    it 'returns correct heading when points are the same' do
+      other = @instance.clone
+      expect(@instance.heading(other)).to eq RTanque::Heading::N
+    end
+  end
+
+  context '#==' do
+    it 'is true when x & y are equal' do
+      a = described_class.new(1, 1, @arena)
+      b = described_class.new(1, 1, @arena)
+      expect(a == b).to be_true
+      expect(b == a).to be_true
+    end
+
+    it 'is not true when x & y are equal' do
+      a = described_class.new(2, 1, @arena)
+      b = described_class.new(1, 1, @arena)
+      expect(a == b).to be_false
+      expect(b == a).to be_false
+    end
+  end
+
+  context '#move' do
+    before do
+      @init_x, @init_y = 0.0, 0.0
+      @point = RTanque::Point.new(@init_x, @init_y, @arena)
+      @heading = RTanque::Heading.new(RTanque::Heading::NORTH)
+    end
+
+    it 'should not move if no speed' do
+      new_point = @point.move(@heading, 0)
+      expect(new_point.x).to eq @init_x
+      expect(new_point.y).to eq @init_y
+    end
+
+    it 'should move on y axis' do
+      new_point = @point.move(@heading, 1)
+      expect(new_point.x).to eq @init_x
+      expect(new_point.y).to eq @init_y + 1
+    end
+
+    it 'should move on x axis' do
+      @heading = RTanque::Heading.new(RTanque::Heading::EAST)
+      new_point = @point.move(@heading, 1)
+      expect(new_point.x).to eq @init_x + 1
+      expect(new_point.y).to eq @init_y
+    end
+
+    it 'should move on y axis twice' do
+      @heading = RTanque::Heading.new(RTanque::Heading::EAST)
+      new_point = @point.move(@heading, 1).move(@heading, 1)
+      expect(new_point.x).to eq @init_x + 2
+      expect(new_point.y).to eq @init_y
+    end
+
+    it 'should move on x and y axis' do
+      @heading = RTanque::Heading.new(RTanque::Heading::NORTH_EAST)
+      new_point = @point.move(@heading, Math.hypot(1,1) * 2)
+      expect(new_point.x).to eq @init_x + 2
+      expect(new_point.y).to eq @init_y + 2
+    end
+
+    it 'should move on x and y axis forwards and backwards' do
+      @heading = RTanque::Heading.new(RTanque::Heading::NORTH_EAST)
+      new_point = @point.move(@heading, Math.hypot(1,1) * 2)
+      expect(new_point.x).to eq @init_x + 2
+      expect(new_point.y).to eq @init_y + 2
+      new_point = @point.move(@heading, -Math.hypot(1,1) * 2)
+      expect(new_point.x).to eq @init_x
+      expect(new_point.y).to eq @init_y
+    end
+
+    it 'should stay within arena when bound' do
+      @heading = RTanque::Heading.new(RTanque::Heading::NORTH_EAST)
+      new_point = @point.move(@heading, Math.hypot(1,1) * 1000)
+      expect(new_point.x).to eq @arena.width
+      expect(new_point.y).to eq @arena.height
+
+      @heading = RTanque::Heading.new(RTanque::Heading::NORTH_EAST)
+      new_point = @point.move(@heading, Math.hypot(1,1) * -1000)
+      expect(new_point.x).to eq @init_x
+      expect(new_point.y).to eq @init_y
+    end
+  end
+
+  describe '#within_radius?' do
+    before do
+      @a = described_class.new(5, 5, @arena)
+    end
+
+    it 'correctly detects equal points' do
+      @b = @a.clone
+      expect(@a.within_radius?(@b, 1)).to be_true
+    end
+
+    it 'correctly detects point 1 to left' do
+      @b = described_class.new(4, 5, @arena)
+      expect(@a.within_radius?(@b, 1)).to be_true
+    end
+
+    it 'correctly detects point 1 to right' do
+      @b = described_class.new(6, 5, @arena)
+      expect(@a.within_radius?(@b, 1)).to be_true
+    end
+
+    it 'correctly detects point 1 above' do
+      @b = described_class.new(5, 6, @arena)
+      expect(@a.within_radius?(@b, 1)).to be_true
+    end
+
+    it 'correctly detects point 1 below' do
+      @b = described_class.new(5, 4, @arena)
+      expect(@a.within_radius?(@b, 1)).to be_true
+    end
+
+    it 'correctly detects point 1 NE' do
+      @b = described_class.new(6, 6, @arena)
+      expect(@a.within_radius?(@b, 1)).to be_false
+    end
+  end
+end

data/spec/rtanque/radar_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe RTanque::Bot::Radar do
+  def reflection(heading, distance, name)
+    described_class::Reflection.new(RTanque::Heading.new(heading), distance, name)
+  end
+
+  let(:radar) { described_class.new(mockbot(10, 10), RTanque::Heading.new(0)) }
+
+  context '#scan' do
+    it 'should return an array' do
+      radar.scan([])
+      expect(radar.to_a).to be_an_instance_of Array
+    end
+
+    it 'should return an empty array' do
+      radar.scan([])
+      expect(radar.empty?).to be_true
+    end
+
+    it 'should 1 Reflection' do
+      radar.scan([mockbot(10, 20)])
+      expect(radar).to have(1).reflections
+      expect(radar.first).to be_an_instance_of described_class::Reflection
+    end
+
+    it 'reflection should be correct' do
+      radar.scan([mockbot(10, 20, 'otherbot')])
+      expect(radar.first).to eq reflection(0, 10.0, 'otherbot')
+    end
+
+    it 'should clear self' do
+      radar.scan([mockbot(10, 20, 'otherbot')])
+      radar.scan([])
+      expect(radar.empty?).to be_true
+    end
+
+    it 'reflections should be correct' do
+      bots = [mockbot(10, 20, 'below'), mockbot(10, 50, 'right')]
+      radar.scan(bots)
+      expect(radar.to_a).to include(
+        reflection(RTanque::Heading::N, 10.0, 'below'),
+        reflection(RTanque::Heading::N, 40.0, 'right')
+      )
+    end
+
+    it 'should detect bot in same position' do
+      bots = [mockbot(10, 10, 'ontop')]
+      radar.scan(bots)
+      expect(radar.to_a).to include(
+        reflection(RTanque::Heading::N, 0.0, 'ontop')
+      )
+    end
+
+    it 'should detect point on max vision range' do
+      x = 10 + Math.sin(RTanque::Bot::Radar::VISION_RANGE.last) * 10
+      y = 10 + Math.cos(RTanque::Bot::Radar::VISION_RANGE.last) * 10
+      bots = [mockbot(x, y, 'border')]
+      radar.scan(bots)
+      expect(radar.to_a).to have(1).reflections
+    end
+
+    it 'should detect point on min vision range' do
+      x = 10 + Math.sin(RTanque::Bot::Radar::VISION_RANGE.first) * 10
+      y = 10 + Math.cos(RTanque::Bot::Radar::VISION_RANGE.first) * 10
+      bots = [mockbot(x, y, 'border')]
+      radar.scan(bots)
+      expect(radar.to_a).to have(1).reflections
+    end
+
+    it 'should not detect point outside max vision range' do
+      x = 10 + Math.sin(RTanque::Bot::Radar::VISION_RANGE.last) * 10
+      y = 10 + Math.cos(RTanque::Bot::Radar::VISION_RANGE.last) * 10
+      bots = [mockbot(x + 0.01, y, 'border')]
+      radar.scan(bots)
+      expect(radar.to_a).to have(0).reflections
+    end
+
+    it 'should not detect point outside max vision range' do
+      x = 10 + Math.sin(RTanque::Bot::Radar::VISION_RANGE.first) * 10
+      y = 10 + Math.cos(RTanque::Bot::Radar::VISION_RANGE.first) * 10
+      bots = [mockbot(x, y - 0.01, 'border')]
+      radar.scan(bots)
+      expect(radar.to_a).to have(0).reflections
+    end
+  end
+end

data/spec/rtanque/shell_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe RTanque::Shell do
+  let(:bot) { mockbot(10, 10, 'shooter') }
+  let(:shell) { described_class.new(bot, RTanque::Point.new(10, 10, @arena), RTanque::Heading.new(0), 1) }
+
+  context '#hits' do
+    it 'should yield no bots' do
+      bots = []
+      expect{ |p| shell.hits(bots, &p) }.not_to yield_control
+    end
+
+    it 'should yield hit bot' do
+      bots = [mockbot(10, 10, 'deadbot')]
+      expect { |p| shell.hits(bots, &p) }.to yield_with_args(bot, bots[0])
+    end
+
+    it 'shell should be dead after hit' do
+      bots = [mockbot(10, 10, 'deadbot')]
+      expect(shell.dead?).to be_false
+      shell.hits(bots)
+      expect(shell.dead?).to be_true
+    end
+
+    it 'should hit shell on bot radius' do
+      bots = [mockbot(10 + RTanque::Bot::RADIUS, 10, 'deadbot')]
+      expect { |p| shell.hits(bots, &p) }.to yield_with_args(bot, bots[0])
+    end
+
+    it 'should not hit shell outside bot radius' do
+      bots = [mockbot(10 + RTanque::Bot::RADIUS + 0.01, 10, 'deadbot')]
+      expect { |p| shell.hits(bots, &p) }.not_to yield_with_args(bot, bots[0])
+    end
+  end
+end