colstrom-rtanque 0.1.3

data/lib/rtanque/normalized_attr.rb

@@ -0,0 +1,69 @@
+module RTanque
+  module NormalizedAttr
+    MAX_DELTA = 1.0 / 0.0 # INFINITY
+    def attr_normalized(attr_name, range, max_delta = MAX_DELTA)
+      @_normalized_attrs ||= {}
+      @_normalized_attrs[attr_name] = AttrContainer.new(range, max_delta)
+      const_set("MAX_#{attr_name.to_s.upcase}", @_normalized_attrs[attr_name].max)
+      const_set("MIN_#{attr_name.to_s.upcase}", @_normalized_attrs[attr_name].min)
+      define_method("normalize_#{attr_name}") do |current_value, new_value|
+        return new_value unless new_value
+        self.class.normalized_attrs(attr_name).normalize(self, current_value, new_value)
+      end
+    end
+
+    def normalized_attrs(attr_name)
+      @_normalized_attrs.fetch(attr_name)
+    end
+
+    class AttrContainer
+      def initialize(range, max_delta = MAX_DELTA)
+        @range = range
+        @max_delta = max_delta
+      end
+
+      def min
+        @range.first
+      end
+
+      def max
+        @range.last
+      end
+
+      def normalize(attached_instance, current_value, new_value)
+        self.enforce_range(self.enforce_delta(attached_instance, current_value, new_value))
+      end
+
+      def max_delta(attached_instance)
+        @max_delta.respond_to?(:call) ? @max_delta.call(attached_instance) : @max_delta
+      end
+
+      def enforce_delta(attached_instance, current_value, new_value)
+        current_delta = self.delta(current_value, new_value)
+        current_max_delta = self.max_delta(attached_instance)
+        if current_delta.abs > current_max_delta
+          current_delta > 0 ? current_value + current_max_delta : current_value - current_max_delta
+        else
+          new_value
+        end
+      end
+
+      def delta(current_value, new_value)
+        if current_value
+          # Heading responds to delta
+          current_value.respond_to?(:delta) ? current_value.delta(new_value) : (new_value - current_value)
+        else
+          0
+        end
+      end
+
+      def enforce_range(value)
+        if @range.include?(value)
+          value
+        else
+          value > self.max ? self.max : self.min
+        end
+      end
+    end
+  end
+end

data/lib/rtanque/point.rb

@@ -0,0 +1,140 @@
+module RTanque
+  # A `Point` represents an [x, y] coordinate pair in the {RTanque::Arena}
+  #
+  # ##Usage
+  #     @arena = RTanque::Arena.new(100, 100)
+  #     # => #<struct RTanque::Arena width=100, height=100>
+  #
+  #     @point_one = RTanque::Point.new(0, 1, @arena)
+  #     # => #<struct RTanque::Point x=0, y=1, arena=#<struct RTanque::Arena width=100, height=100>>
+  #
+  #     @point_one.on_top_wall?
+  #     # => false
+  #
+  #     @point_one.on_bottom_wall?
+  #     # => false
+  #
+  #     @point_one.on_right_wall?
+  #     # => false
+  #
+  #     @point_one.on_left_wall?
+  #     # => true
+  #
+  #     @point_one.on_wall?
+  #     # => true
+  #
+  #     @point_two = RTanque::Point.new(100, 1, @arena)
+  #     # => #<struct RTanque::Point x=100, y=1, arena=#<struct RTanque::Arena width=100, height=100>>
+  #
+  #     @point_two.within_radius?(@point_one, 10)
+  #     # => false
+  #
+  #     @point_two.within_radius?(@point_one, 100)
+  #     # => true
+  #
+  #     @point_two.distance(@point_one)
+  #     # => 100.0
+  #
+  # @attr_reader [Numeric] x horizontal position (left edge is 0)
+  # @attr_reader [Numeric] y vertical position (bottom edge is 0)
+  # @attr_reader [RTanque::Arena] arena
+  #
+  # @!method distance(other_point) distance to other point
+  #    @param [RTanque::Point]
+  #    @return [Float]
+  #
+  # @!method heading(other_point) heading to other point
+  #    @param [RTanque::Point]
+  #    @return [RTanque::Heading]
+  #
+  # @!method on_top_wall?
+  #    @return [Boolean]
+  #
+  # @!method on_bottom_wall?
+  #    @return [Boolean]
+  #
+  # @!method on_right_wall?
+  #    @return [Boolean]
+  #
+  # @!method on_left_wall?
+  #    @return [Boolean]
+  #
+  # @!method on_wall?
+  #    True if on any wall
+  #    @return [Boolean]
+  Point = Struct.new(:x, :y, :arena) do
+    def initialize(*args, &block)
+      super
+      block.call(self) if block
+      self.freeze
+    end
+
+    def self.rand(arena)
+      self.new(Kernel.rand(arena.width), Kernel.rand(arena.height), arena)
+    end
+
+    def self.distance(a, b)
+      Math.hypot(a.x - b.x, a.y - b.y)
+    end
+
+    def ==(other_point)
+      self.x == other_point.x && self.y == other_point.y
+    end
+
+    def within_radius?(other_point, radius)
+      self.distance(other_point) <= radius
+    end
+
+    def on_top_wall?
+      self.y >= self.arena.height
+    end
+
+    def on_bottom_wall?
+      self.y <= 0
+    end
+
+    def on_left_wall?
+      self.x <= 0
+    end
+
+    def on_right_wall?
+      self.x >= self.arena.width
+    end
+
+    def on_wall?
+      self.on_top_wall? || self.on_bottom_wall? || self.on_right_wall? || self.on_left_wall?
+    end
+
+    def outside_arena?
+      self.y > self.arena.height || self.y < 0 || self.x > self.arena.width || self.x < 0
+    end
+
+    def move(heading, speed, bound_to_arena = true)
+      # round to avoid floating point errors
+      x = (self.x + (Math.sin(heading) * speed)).round(10)
+      y = (self.y + (Math.cos(heading) * speed)).round(10)
+      self.class.new(x, y, self.arena) { |point| point.bind_to_arena if bound_to_arena }
+    end
+
+    def bind_to_arena
+      if self.x < 0
+        self.x = 0.0
+      elsif self.x > self.arena.width
+        self.x = self.arena.width.to_f
+      end
+      if self.y < 0
+        self.y = 0.0
+      elsif self.y > self.arena.height
+        self.y = self.arena.height.to_f
+      end
+    end
+
+    def heading(other_point)
+      Heading.new_between_points(self, other_point)
+    end
+
+    def distance(other_point)
+      self.class.distance(self, other_point)
+    end
+  end
+end

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,44 @@
+module RTanque
+  class Shell
+    include Movable
+    RATIO = Configuration.shell.ratio
+    SHELL_SPEED_FACTOR = Configuration.shell.speed_factor
+    attr_reader :bot, :arena, :fire_power
+
+    def self.speed fire_power
+      fire_power * SHELL_SPEED_FACTOR
+    end
+
+    def initialize(bot, position, heading, fire_power)
+      @bot = bot
+      @arena = bot.arena
+      @fire_power = fire_power
+      self.position = position
+      self.heading = heading
+      self.speed = self.class.speed(fire_power) # 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.1.3'
+end