colstrom-rtanque 0.1.3

data/rtanque.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rtanque/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "colstrom-rtanque"
+  gem.version       = RTanque::VERSION
+  gem.authors       = ["Adam Williams"]
+  gem.email         = ["pwnfactory@gmail.com"]
+  gem.summary       = %q{RTanque is a game for programmers. Players program the brain of a tank and then send their tank into battle against other tanks.}
+  gem.description   = %q{RTanque is a game for programmers. Players program the brain of a tank and then send their tank+brain into battle with other tanks. All tanks are otherwise equal.
+
+Rules of the game are simple: Last bot standing wins. Gameplay is also pretty simple. Each tank has a base, turret and radar, each of which rotate independently. The base moves the tank, the turret has a gun mounted to it which can fire at other tanks, and the radar detects other tanks in its field of vision.
+
+Have fun competing against friends' tanks or the sample ones included. Maybe you'll start a small league at your local Ruby meetup.} 
+  gem.homepage      = "https://github.com/awilliams/RTanque"
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'gosu', '~> 0.10', '>= 0.7.45'
+  gem.add_dependency 'configuration', '~> 1.3.2'
+  gem.add_dependency 'octokit', '~> 2.7.0'
+  gem.add_dependency 'thor', '~> 0.17.0'
+  gem.add_dependency 'texplay', '~> 0.4', '>= 0.4.3'
+
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rspec', '~> 2.13.0'
+  gem.add_development_dependency 'rspec-mocks', '~> 2.13.0'
+end

data/sample_bots/camper.rb

@@ -0,0 +1,79 @@
+# Camper: Sample Bot
+#
+# Enjoys sitting in the corners and firing powerful shots
+class Camper < RTanque::Bot::Brain
+  NAME = 'Camper'
+  include RTanque::Bot::BrainHelper
+
+  CORNERS = [:NW, :NE, :SE, :SW]
+  TURRET_FIRE_RANGE = RTanque::Heading::ONE_DEGREE * 1.0
+  SWITCH_CORNER_TICK_RANGE = (600..1000)
+
+  def tick!
+    self.hide_in_corners
+    if (target = self.nearest_target)
+      self.fire_upon(target)
+    else
+      self.detect_targets
+    end
+  end
+
+  def fire_upon(target)
+    self.command.radar_heading = target.heading
+    self.command.turret_heading = target.heading
+    if self.sensors.turret_heading.delta(target.heading).abs < TURRET_FIRE_RANGE
+      self.command.fire(MAX_FIRE_POWER)
+    end
+  end
+
+  def nearest_target
+    self.sensors.radar.min { |a,b| a.distance <=> b.distance }
+  end
+
+  def detect_targets
+    self.command.radar_heading = self.sensors.radar_heading + MAX_RADAR_ROTATION
+    self.command.turret_heading = self.sensors.heading + RTanque::Heading::HALF_ANGLE
+  end
+
+  def hide_in_corners
+    @corner_cycle ||= CORNERS.shuffle.cycle
+    self.at_tick_interval(self.camp_interval) {
+      self.corner = @corner_cycle.next
+      self.reset_camp_interval
+    }
+    self.corner ||= @corner_cycle.next
+    self.move_to_corner
+  end
+
+  def move_to_corner
+    if self.corner
+      command.heading = self.sensors.position.heading(RTanque::Point.new(*self.corner, self.arena))
+      command.speed = MAX_BOT_SPEED
+    end
+  end
+
+  def corner=(corner_name)
+    @corner = case corner_name
+      when :NE
+        [self.arena.width, self.arena.height]
+      when :SE
+        [self.arena.width, 0]
+      when :SW
+        [0, 0]
+      else
+        [0, self.arena.height]
+    end
+  end
+
+  def corner
+    @corner
+  end
+
+  def camp_interval
+    @camp_interval ||= self.reset_camp_interval
+  end
+
+  def reset_camp_interval
+    @camp_interval = rand(SWITCH_CORNER_TICK_RANGE.max - SWITCH_CORNER_TICK_RANGE.min) + SWITCH_CORNER_TICK_RANGE.min
+  end
+end

data/sample_bots/keyboard.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+# Keyboard: Sample Bot
+#
+# Special bot controlled with the keyboard
+#
+# Controls:
+#   w   drive forward
+#   s   drive backwards
+#   a   rotate left
+#   d   rotate right
+#
+#   ↑   fire powerful shot
+#   ↓   fire week shot
+#   ←   rotate turret left
+#   →   rotate turret right
+class Keyboard < RTanque::Bot::Brain
+  include RTanque::Bot::BrainHelper
+
+  NAME = 'Keyboard'
+
+  def tick!
+    command.radar_heading = sensors.radar_heading + (RTanque::Heading::ONE_DEGREE * 30)
+
+    if sensors.button_down?(Gosu::KbLeft)
+      command.turret_heading = sensors.turret_heading - (RTanque::Heading::ONE_DEGREE * 10)
+    elsif sensors.button_down?(Gosu::KbRight)
+      command.turret_heading = sensors.turret_heading + (RTanque::Heading::ONE_DEGREE * 10)
+    end
+
+    if sensors.button_down?('a')
+      command.heading = sensors.heading - (RTanque::Heading::ONE_DEGREE * 10)
+    elsif sensors.button_down?('d')
+      command.heading = sensors.heading + (RTanque::Heading::ONE_DEGREE * 10)
+    end
+
+    if sensors.button_down?('w')
+      command.speed = 10
+    elsif sensors.button_down?('s')
+      command.speed = -10
+    else
+      command.speed = 0
+    end
+
+    if sensors.button_down?(Gosu::KbUp)
+      command.fire_power = 5
+    elsif sensors.button_down?(Gosu::KbDown)
+      command.fire_power = 1
+    end
+  end
+end

data/sample_bots/seek_and_destroy.rb

@@ -0,0 +1,53 @@
+# 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!
+    @desired_heading ||= nil
+
+    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