ruby_arena 0.0.2

data/spec/command_parser_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe RubyArena:: CommandParser do
+  describe '#turn' do
+    it 'sets turn to given value' do
+      command_parser.turn(10)
+
+      expect(command_parser.actions[:turn]).to be 10
+    end
+  end
+
+  describe '#turn_gun' do
+    it 'sets turn_gun action to given value' do
+      command_parser.turn_gun(20)
+
+      expect(command_parser.actions[:turn_gun]).to be 20
+    end
+  end
+
+  describe '#turn_radar' do
+    it 'sets turn_radar action to given value' do
+      command_parser.turn_radar(20)
+
+      expect(command_parser.actions[:turn_radar]).to be 20
+    end
+  end
+
+  describe '#accelerate' do
+    it 'accelerates' do
+      command_parser.accelerate
+
+      expect(command_parser.actions[:accelerate]).to be true
+    end
+  end
+
+  describe '#decelerate' do
+    it 'decelerates' do
+      command_parser.decelerate
+
+      expect(command_parser.actions[:decelerate]).to be true
+    end
+  end
+
+  describe '#fire' do
+    it 'fires a bullet' do
+      command_parser.fire
+
+      expect(command_parser.actions[:fire]).to be true
+    end
+  end
+
+  describe '#change_radar_view' do
+    it 'sets radar view angle' do
+      command_parser.radar_view_angle(10)
+
+      expect(command_parser.actions[:radar_view_angle]).to be 10
+    end
+  end
+
+  describe '#reset_actions' do
+    it 'reset actions hash' do
+      command_parser.turn(10)
+      command_parser.reset_actions
+
+      expect(command_parser.actions).to eq({})
+    end
+  end
+
+  def command_parser
+    @_command_parser ||= RubyArena::CommandParser.new
+  end
+end

data/spec/fake_gui.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class FakeGosuWindow
+  def stub(*args)
+    true
+  end
+
+  alias initialize    stub
+  alias draw_quad     stub
+  alias draw_triangle stub
+  alias rotate        stub
+end
+
+GosuWindowBackup = Gosu::Window
+Gosu.send(:remove_const, :Window)
+Gosu::Window = FakeGosuWindow
+
+GuiBackup = RubyArena::Gui
+RubyArena.send(:remove_const, :Gui)
+
+load 'ruby_arena/gui.rb' # reload gui.rb after stubbing
+
+FakeGui = RubyArena::Gui # catch the stubbed gui
+
+RubyArena::send(:remove_const, :Gui)
+RubyArena::Gui = GuiBackup # restore things
+Gosu.send(:remove_const, :Window)
+Gosu::Window = GosuWindowBackup

data/spec/game_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe RubyArena:: Game do
+end

data/spec/gui_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe RubyArena:: Gui do
+  let(:robot) do
+    double('robot',
+            heading: 0,
+            radar_heading: 0,
+            gun_heading: 0,
+            x: 0,
+            y: 0,
+            size: 10,
+            radar_view_angle: 10,
+            radar_range: 100 )
+  end
+  let(:bullet) { double('bullet', heading: 0, x: 0, y: 0, size: 2) }
+  let(:arena)  { double('arena', width: 800, height: 600, robots: [robot], bullets: [bullet]) }
+  let(:gui)    { FakeGui.new(arena) }
+
+  describe 'public interface' do
+    it { expect(gui).to respond_to(:draw) }
+  end
+
+  describe '#update' do
+    it 'notifies arena' do
+      expect(arena).to receive(:update)
+
+      gui.update
+    end
+  end
+
+  describe '#draw' do
+    it 'notifies each robot renderer' do
+      robot_renderer = double('robot_renderer')
+      allow(RubyArena::RobotRenderer).to receive(:new) { robot_renderer }
+
+      expect(robot_renderer).to receive(:draw)
+
+      gui.draw
+    end
+
+    it 'notifies each bullet renderer' do
+      bullet_renderer = double('bullet_renderer')
+      allow(RubyArena::BulletRenderer).to receive(:new) { bullet_renderer }
+
+      expect(bullet_renderer).to receive(:draw)
+
+      gui.draw
+    end
+  end
+end

data/spec/level_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe RubyArena::Level do
+  before do
+    allow_any_instance_of(IO).to receive(:puts).and_return nil
+  end
+
+  describe '#initialize' do
+    it 'exits when level is not defined' do
+      expect { RubyArena::Level.new(:undefined_level) }.to raise_error SystemExit
+    end
+  end
+
+  describe '#options_for_cpu_robots' do
+    it 'returns options for cpu robots' do
+      level = RubyArena::Level.new(0)
+
+      expect(level.options_for_cpu_robots.first).to eq({ ai: RubyArena::Level0, x: 600, y: 300 })
+    end
+  end
+
+  describe '#options_for_user_robot' do
+    it 'returns options for user robot' do
+      level = RubyArena::Level.new(0)
+
+      expect(level.options_for_user_robot).to eq({ x: 200, y: 300 })
+    end
+  end
+end

data/spec/movable_tests.rb

@@ -0,0 +1,48 @@
+shared_examples 'movable' do
+  describe 'public interface' do
+    it_responds_to(:x)
+    it_responds_to(:y)
+    it_responds_to(:speed)
+    it_responds_to(:heading)
+  end
+
+  describe '#move' do
+    it 'changes y coordinate by -1 when speed is 1 and heading is 0' do
+      object = object(x: 0, y: 0, heading: 0, speed: 1)
+
+      object.move
+
+      expect(object.y).to eq(-1)
+    end
+
+    it 'changes y coordinate by 1 when speed is 1 and heading is 180' do
+      object = object(x: 0, y: 0, heading: 180, speed: 1)
+
+      object.move
+
+      expect(object.y).to eq(1)
+    end
+
+    it 'changes x coordinate by 1 when speed is 1 and heading is 90' do
+      object = object(x: 0, y: 0, heading: 90, speed: 1)
+
+      object.move
+
+      expect(object.x).to eq(1)
+    end
+
+    it 'changes x coordinate by -1 when speed is 1 and heading is 270' do
+      object = object(x: 0, y: 0, heading: 270, speed: 1)
+
+      object.move
+
+      expect(object.x).to eq(-1)
+    end
+  end
+end
+
+def it_responds_to(method)
+  it "responds to ##{method}" do
+    expect(object).to respond_to(method)
+  end
+end

data/spec/option_parser_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe OptionParser do
+  describe '.parse' do
+    it 'returns {level: 1} when ["-l", "1"] is given' do
+      options = OptionParser.parse(['-l', '1'])
+
+      expect(options).to eq({level: 1})
+    end
+
+    it 'returns {level: 1} when ["--level", "1"] is given' do
+      options = OptionParser.parse(['--level', '1'])
+
+      expect(options).to eq({level: 1})
+    end
+
+    it 'prints help when no arguments are given' do
+      begin
+        output = capture_stdout { OptionParser.parse([]) }
+        expect(output).to include "Usage:"
+      rescue SystemExit
+      end
+    end
+
+    it 'prints help when -h is given' do
+      begin
+        output = capture_stdout { OptionParser.parse(['-h']) }
+        expect(output).to include "Usage:"
+      rescue SystemExit
+      end
+    end
+
+    it 'exits when -h is given' do
+      expect do
+        capture_stdout { OptionParser.parse(['-h']) }
+      end.to raise_error SystemExit
+    end
+  end
+end
+
+def capture_stdout &block
+  old_stdout = $stdout
+  fake_stdout = StringIO.new
+  $stdout = fake_stdout
+  block.call
+  fake_stdout.string
+ensure
+  $stdout = old_stdout
+end

data/spec/robot_renderer_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe RubyArena:: RobotRenderer do
+end

data/spec/robot_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+describe RubyArena:: Robot do
+  let(:klass) { Robot }
+
+  it_behaves_like 'movable'
+
+  describe '#tick' do
+    it 'notifies AI' do
+      expect(robot.ai).to receive(:tick)
+
+      robot.tick
+    end
+
+    it 'decreases gun heat by 0.1 if it is more than 0' do
+      robot = robot(gun_heat: 1)
+      expect(robot.ai).to receive(:tick)
+
+      robot.tick
+
+      expect(robot.gun_heat).to eq(0.9)
+    end
+
+    it "doesn't decrease gun heat below 0" do
+      robot = robot(gun_heat: 0)
+      expect(robot.ai).to receive(:tick)
+
+      robot.tick
+
+      expect(robot.gun_heat).to be 0
+    end
+
+  end
+
+  describe '#update' do
+    it 'calls #execute_actions and #move on robot' do
+      expect(robot.command_parser).to receive(:actions)
+      expect(robot.command_parser).to receive(:reset_actions)
+      expect(robot).to receive(:execute_actions)
+      expect(robot).to receive(:move)
+
+      robot.update
+    end
+  end
+
+  describe '#accelerate' do
+    it 'increases speed by 1' do
+      robot.accelerate
+
+      expect(robot.speed).to be 1
+    end
+
+    it 'increases speed max to MAX_SPEED' do
+      10.times { robot.accelerate }
+
+      expect(robot.speed).to be 8
+    end
+  end
+
+  describe '#decelerate' do
+    it 'decreases speed by 1' do
+      robot.decelerate
+
+      expect(robot.speed).to be(-1)
+    end
+
+    it 'decreases speed max to -MAX_SPEED' do
+      10.times { robot.decelerate }
+
+      expect(robot.speed).to be(-8)
+    end
+  end
+
+  describe '#turn' do
+    it 'changes heading by given value' do
+      robot = robot(heading: 0)
+
+      robot.turn(5)
+
+      expect(robot.heading).to be 5
+    end
+
+    it 'changes heading maximum by MAX_TURN_ANGLE' do
+      robot = robot(heading: 0)
+
+      robot.turn(100)
+
+      expect(robot.heading).to be RubyArena::Robot::MAX_TURN_ANGLE
+    end
+
+    it 'changes heading maximum by MAX_TURN_ANGLE for negative values' do
+      robot = robot(heading: 100)
+
+      robot.turn(-100)
+
+      expect(robot.heading).to be(100-RubyArena::Robot::MAX_TURN_ANGLE)
+    end
+
+    it 'changes gun heading by given value' do
+      robot = robot(heading: 0)
+
+      robot.turn(5)
+
+      expect(robot.gun_heading).to be 5
+    end
+
+    it 'changes radar heading by given value' do
+      robot = robot(heading: 0)
+
+      robot.turn(5)
+
+      expect(robot.radar_heading).to be 5
+    end
+  end
+
+  describe '#turn_gun' do
+    it 'changes gun heading by given value' do
+      robot = robot(heading: 0)
+
+      robot.turn_gun(10)
+
+      expect(robot.gun_heading).to be 10
+    end
+
+    it 'changes gun heading maximum by MAX_TURN_GUN_ANGLE' do
+      robot = robot(gun_heading: 0)
+
+      robot.turn_gun(100)
+
+      expect(robot.gun_heading).to be RubyArena::Robot::MAX_TURN_GUN_ANGLE
+    end
+
+    it 'changes gun heading maximum by MAX_TURN_GUN_ANGLE for negative values' do
+      robot = robot(gun_heading: 100)
+
+      robot.turn_gun(-100)
+
+      expect(robot.gun_heading).to be(100-RubyArena::Robot::MAX_TURN_GUN_ANGLE)
+    end
+
+    it 'changes radar heading by given value' do
+      robot = robot(heading: 0)
+
+      robot.turn_gun(30)
+
+      expect(robot.radar_heading).to be 30
+    end
+  end
+
+  describe '#turn_radar' do
+    it 'changes radar heading by given value' do
+      robot = robot(heading: 0)
+
+      robot.turn_radar(10)
+
+      expect(robot.radar_heading).to be 10
+    end
+
+    it 'changes radar heading maximum by MAX_TURN_RADAR_ANGLE' do
+      robot = robot(radar_heading: 0)
+
+      robot.turn_radar(100)
+
+      expect(robot.radar_heading).to be RubyArena::Robot::MAX_TURN_RADAR_ANGLE
+    end
+
+    it 'changes radar heading maximum by MAX_TURN_RADAR_ANGLE for negative values' do
+      robot = robot(radar_heading: 100)
+
+      robot.turn_radar(-100)
+
+      expect(robot.radar_heading).to be(100-RubyArena::Robot::MAX_TURN_RADAR_ANGLE)
+    end
+  end
+
+  describe '#fire' do
+    it 'adds new bullet to arena' do
+      expect(arena).to receive(:add_bullet)
+
+      robot.fire
+    end
+
+    it 'increases gun heat' do
+      robot.fire
+
+      expect(robot.gun_heat).to be 3
+    end
+
+    it "doesn't fire if gun heat is more than 0" do
+      robot = robot(gun_heat: 3)
+
+      expect(arena).not_to receive(:add_bullet)
+
+      robot.fire
+    end
+  end
+
+  describe '#execute_actions' do
+    it 'turns robot if turn action is set' do
+      expect(robot).to receive(:turn).with(10)
+
+      robot.execute_actions({ turn: 10 })
+    end
+
+    it 'turns gun if turn_gun action is set' do
+      expect(robot).to receive(:turn_gun).with(20)
+
+      robot.execute_actions({ turn_gun: 20 })
+    end
+
+    it 'turns radar if turn_radar action is set' do
+      expect(robot).to receive(:turn_radar).with(30)
+
+      robot.execute_actions({ turn_radar: 30 })
+    end
+
+    it 'accelerate if accelerate action is set' do
+      expect(robot).to receive(:accelerate)
+
+      robot.execute_actions({ accelerate: true })
+    end
+
+    it 'decelerate if decelerate action is set' do
+      expect(robot).to receive(:decelerate)
+
+      robot.execute_actions({ decelerate: true })
+    end
+
+    it 'fires if fire action is set' do
+      expect(robot).to receive(:fire)
+
+      robot.execute_actions({ fire: true })
+    end
+
+    it 'changes radar view angle if radar view angle action is set' do
+      robot = robot(radar_view_angle: 10)
+
+      robot.execute_actions({ radar_view_angle: 5 })
+
+      expect(robot.radar_view_angle).to be 5
+    end
+  end
+
+  describe '#hit' do
+    it 'decreases energy by bullet energy' do
+      robot = robot(energy: 100)
+      bullet = double('bullet', energy: 10)
+
+      robot.hit(bullet)
+
+      expect(robot.energy).to be 90
+    end
+  end
+
+  describe '#dead?' do
+    it 'returns false if energy is more than 0' do
+      expect(robot.dead?).to be false
+    end
+
+    it 'returns true if energy is less than 0' do
+      robot = robot(energy: -1)
+
+      expect(robot.dead?).to be true
+    end
+  end
+
+  describe '#scan' do
+    it 'returns distance from all robots in radar view and range' do
+      robot_in_radar_view = double('robot_in_radar_view', x: 200, y: 100)
+      robot_not_in_radar_view = double('robot_not_in_radar_view', x: 0, y: 0)
+      arena = double('arena', robots: [robot_in_radar_view, robot_not_in_radar_view])
+      robot = robot(x: 100, y: 100, heading: 90, arena: arena)
+
+      expect(robot.scan).to eq [100]
+    end
+  end
+
+  def object(args = {})
+    robot(args)
+  end
+
+  def robot(args = {})
+    defaults = {
+      ai: RSpec::Mocks::Mock,
+      arena: arena
+    }
+
+    @_robot ||= RubyArena::Robot.new(defaults.merge(args))
+  end
+
+  def arena
+    @_arena ||= double('arena', robots: [], width: 100, height: 100, add_bullet: nil)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'ruby_arena'
+
+require 'ai_test'
+require 'fake_gui'
+require 'movable_tests'
+
+RSpec.configure do |config|
+end

data/spec/value_sanitizer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe RubyArena::ValueSanitizer do
+  describe '.sanitize' do
+    it 'returns 1 when value is 1 and max change is 10' do
+      expect(RubyArena::ValueSanitizer.sanitize(1, 10)).to be 1
+    end
+
+    it 'returns 10 when value is 100 and max change is 10' do
+      expect(RubyArena::ValueSanitizer.sanitize(100, 10)).to be 10
+    end
+
+    it 'returns -10 when value is -10 and max change is 10' do
+      expect(RubyArena::ValueSanitizer.sanitize(-10, 10)).to be(-10)
+    end
+
+    it 'returns -10 when value is -100 and max change is 10' do
+      expect(RubyArena::ValueSanitizer.sanitize(-100, 10)).to be(-10)
+    end
+  end
+end