colstrom-rtanque 0.1.3

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 = (@instance.delta(RTanque::Heading::S + RTanque::Heading::ONE_DEGREE)).round(5)
+      expected = (RTanque::Heading::ONE_DEGREE * 2).round(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

data/spec/rtanque/match_spec.rb

@@ -0,0 +1,46 @@
+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
+      bot1 = double('bot', :name => "bot1")
+      bot2 = double('bot', :name => "bot2")
+      @instance.add_bots(bot1, bot2)
+      expect(@instance.finished?).to be_false
+    end
+
+    it 'should be true if two or more bots left w/ same name' do
+      @instance.teams = true
+      bot1 = double('bot', :name => "bot1")
+      bot2 = double('bot', :name => "bot1")
+      @instance.add_bots(bot1, bot2)
+      expect(@instance.finished?).to be_true
+    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