rtanque 0.0.2

data/lib/rtanque/runner.rb

@@ -0,0 +1,88 @@
+# Add the working directory so that loading of bots works as expected
+$LOAD_PATH << Dir.pwd
+# Add the gem root dir so that sample_bots can be loaded
+$LOAD_PATH << File.expand_path('../../../', __FILE__)
+
+module RTanque
+  # Runner manages running an {RTanque::Match}
+  class Runner
+    LoadError = Class.new(::LoadError)
+    attr_reader :match
+
+    # @param [Integer] width
+    # @param [Integer] height
+    # @param [*match_args] args provided to {RTanque::Match#initialize}
+    def initialize(width, height, *match_args)
+      @match = RTanque::Match.new(RTanque::Arena.new(width, height), *match_args)
+    end
+
+    # Attempts to load given {RTanque::Bot::Brain} given its path
+    # @param [String] brain_path
+    # @raise [RTanque::Runner::LoadError] if brain could not be loaded
+    def add_brain_path(brain_path)
+      parsed_path = self.parse_brain_path(brain_path)
+      bots = parsed_path.multiplier.times.map { self.new_bots_from_brain_path(parsed_path.path) }.flatten
+      self.match.add_bots(bots)
+    end
+
+    # Starts the match
+    # @param [Boolean] gui if false, runs headless match
+    def start(gui = true)
+      if gui
+        require 'rtanque/gui'
+        window = RTanque::Gui::Window.new(self.match)
+        trap(:INT) { window.close }
+        window.show
+      else
+        trap(:INT) { self.match.stop }
+        self.match.start
+      end
+    end
+
+    protected
+
+    def new_bots_from_brain_path(brain_path)
+      self.fetch_brain_klasses(brain_path).map do |brain_klass|
+        RTanque::Bot.new_random_location(self.match.arena, brain_klass)
+      end
+    end
+
+    def fetch_brain_klasses(brain_path)
+      @load_brain_klass_cache ||= Hash.new do |cache, path|
+        cache[path] = self.get_diff_in_object_space(RTanque::Bot::Brain) {
+          begin
+            require(path)
+          rescue ::LoadError => e
+            raise LoadError, e.message
+          end
+        }
+        raise LoadError, "No class of type #{RTanque::Bot::Brain} found in #{path}" if cache[path].empty?
+        cache[path]
+      end
+      @load_brain_klass_cache[brain_path]
+    end
+
+    def get_diff_in_object_space(klass)
+      current_object_space = self.get_descendants_of_class(klass)
+      yield
+      self.get_descendants_of_class(klass) - current_object_space
+    end
+
+    def get_descendants_of_class(klass)
+      ::ObjectSpace.each_object(::Class).select {|k| k < klass }
+    end
+
+    BRAIN_PATH_PARSER = /\A(.+?)\:[x|X](\d+)\z/
+    # @!visibility private
+    ParsedBrainPath = Struct.new(:path, :multiplier)
+    def parse_brain_path(brain_path)
+      path = brain_path.gsub('\.rb$', '')
+      multiplier = 1
+      brain_path.match(BRAIN_PATH_PARSER) { |m|
+        path = m[1]
+        multiplier = m[2].to_i
+      }
+      ParsedBrainPath.new(path, multiplier)
+    end
+  end
+end

data/lib/rtanque/shell.rb

@@ -0,0 +1,40 @@
+module RTanque
+  class Shell
+    include Movable
+    RATIO = Configuration.shell.ratio
+    SHELL_SPEED_FACTOR = Configuration.shell.speed_factor
+    attr_reader :bot, :arena, :fire_power
+
+    def initialize(bot, position, heading, fire_power)
+      @bot = bot
+      @arena = bot.arena
+      @fire_power = fire_power
+      self.position = position
+      self.heading = heading
+      self.speed = (fire_power * SHELL_SPEED_FACTOR) # TODO: add bot's relative speed in this heading
+      @dead = false
+    end
+
+    def bound_to_arena
+      false
+    end
+
+    def dead?
+      @dead ||= self.position.outside_arena?
+    end
+
+    def dead!
+      @dead = true
+    end
+
+    def hits(bots, &on_hit)
+      bots.each do |hit_bot|
+        if hit_bot.position.within_radius?(self.position, Bot::RADIUS)
+          self.dead!
+          on_hit.call(self.bot, hit_bot) if on_hit
+          break
+        end
+      end
+    end
+  end
+end

data/lib/rtanque/version.rb

@@ -0,0 +1,3 @@
+module RTanque
+  VERSION = '0.0.2'
+end

data/rtanque.gemspec

@@ -0,0 +1,33 @@
+# -*- 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          = "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.7.45'
+  gem.add_dependency 'configuration', '~> 1.3.2'
+  gem.add_dependency 'octokit', '~> 1.23.0'
+  gem.add_dependency 'thor', '~> 0.17.0'
+
+  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