rtanque 0.0.2

data/lib/rtanque/heading.rb

@@ -0,0 +1,172 @@
+# -*- encoding: utf-8 -*-
+module RTanque
+  # A Heading represents an angle. Basically a wrapper around `Float` bound to `(0..Math::PI * 2)`
+  #
+  # 0.0 == `RTanque::Heading::NORTH` is 'up'
+  #
+  # ##Basic Usage
+  #     RTanque::Heading.new(Math::PI)
+  #     # => <RTanque::Heading: 1.0rad 180.0deg>
+  #
+  #     RTanque::Heading.new(Math::PI) + RTanque::Heading.new(Math::PI)
+  #     # => <RTanque::Heading: 0.0rad 0.0deg>
+  #
+  #     RTanque::Heading.new(Math::PI / 2.0) + Math::PI
+  #     # => <RTanque::Heading: 1.5rad 270.0deg>
+  #
+  #     RTanque::Heading.new(0.0) == 0
+  #     # => true
+  #
+  # ##Utility Methods
+  #     RTanque::Heading.new_from_degrees(180.0)
+  #     # => <RTanque::Heading: 1.0rad 180.0deg>
+  #
+  #     RTanque::Heading.new(Math::PI).to_degrees
+  #     # => 180.0
+  #
+  #     RTanque::Heading.new_between_points(RTanque::Point.new(0,0), RTanque::Point.new(2,3))
+  #     # => <RTanque::Heading: 0.1871670418109988rad 33.690067525979785deg>
+  #
+  #     RTanque::Heading.new_from_degrees(1).delta(RTanque::Heading.new_from_degrees(359))
+  #     # => -0.034906585039886195
+  class Heading < Numeric
+    FULL_ANGLE   =      Math::PI * 2.0
+    HALF_ANGLE   =      Math::PI
+    EIGHTH_ANGLE =      Math::PI / 4.0
+    ONE_DEGREE   =      FULL_ANGLE / 360.0
+    FULL_RANGE   =      (0..FULL_ANGLE)
+
+    NORTH = N =         0.0
+    NORTH_EAST = NE =   1.0 * EIGHTH_ANGLE
+    EAST = E =          2.0 * EIGHTH_ANGLE
+    SOUTH_EAST = SE =   3.0 * EIGHTH_ANGLE
+    SOUTH = S =         4.0 * EIGHTH_ANGLE
+    SOUTH_WEST = SW =   5.0 * EIGHTH_ANGLE
+    WEST = W =          6.0 * EIGHTH_ANGLE
+    NORTH_WEST = NW =   7.0 * EIGHTH_ANGLE
+
+    def self.new_from_degrees(degrees)
+      self.new((degrees / 180.0) * Math::PI)
+    end
+
+    def self.new_between_points(from_point, to_point)
+      self.new(from_point == to_point ? 0.0 : Math.atan2(to_point.x - from_point.x, to_point.y - from_point.y))
+    end
+
+    def self.delta_between_points(from_point, from_point_heading, to_point)
+      rel_heading = self.new_between_points(from_point, to_point)
+      self.new(from_point_heading).delta(rel_heading)
+    end
+
+    def self.rand
+      self.new(Float.send(:rand) * FULL_ANGLE)
+    end
+
+    attr_reader :radians
+
+    # Creates a new RTanque::Heading
+    # @param [#to_f] radians degree to wrap (in radians)
+    def initialize(radians = NORTH)
+      @radians = self.extract_radians_from_value(radians) % FULL_ANGLE
+      @memoized = {} # allow memoization since @some_var ||= x doesn't work when frozen
+      self.freeze
+    end
+
+    # difference between `self` and `to` respecting negative angles
+    # @param [#to_f] to
+    # @return [Float]
+    def delta(to)
+      diff = (to.to_f - self.to_f).abs % FULL_ANGLE
+      diff = -(FULL_ANGLE - diff) if diff > Math::PI
+      to < self ? -diff : diff
+    end
+
+    # @return [RTanque::Heading]
+    def clone
+      self.class.new(self.radians)
+    end
+
+    # @param [#to_f] other_heading
+    # @return [Boolean]
+    def ==(other_heading)
+      self.to_f == other_heading.to_f
+    end
+
+    # continue with Numeric's pattern
+    # @param [#to_f] other_heading
+    # @return [Boolean]
+    def eql?(other_heading)
+      other_heading.instance_of?(self.class) && self.==(other_heading)
+    end
+
+    # @param [#to_f] other_heading
+    # @return [Boolean]
+    def <=>(other_heading)
+      self.to_f <=> other_heading.to_f
+    end
+
+    # @param [#to_f] other_heading
+    # @return [RTanque::Heading]
+    def +(other_heading)
+      self.class.new(self.radians + self.extract_radians_from_value(other_heading))
+    end
+
+    # @param [#to_f] other_heading
+    # @return [RTanque::Heading]
+    def -(other_heading)
+      self.+(-other_heading)
+    end
+
+    # @param [#to_f] other_heading
+    # @return [RTanque::Heading]
+    def *(other_heading)
+      self.class.new(self.radians * self.extract_radians_from_value(other_heading))
+    end
+
+    # @param [#to_f] other_heading
+    # @return [RTanque::Heading]
+    def /(other_heading)
+      self.*(1.0 / other_heading)
+    end
+
+    # unary operator
+    # @return [RTanque::Heading]
+    def +@
+      self.class.new(+self.radians)
+    end
+
+    # unary operator
+    # @return [RTanque::Heading]
+    def -@
+      self.class.new(-self.radians)
+    end
+
+    def to_s
+      self.to_f
+    end
+
+    def inspect
+      "<#{self.class.name}: #{self.radians}rad #{self.to_degrees}deg>"
+    end
+
+    # @return [Float]
+    def to_f
+      self.radians
+    end
+
+    # @return [Float]
+    def to_degrees
+      @memoized[:to_degrees] ||= (self.radians * 180.0) / Math::PI
+    end
+
+    protected
+
+    def extract_radians_from_value(value)
+      if value.respond_to?(:radians)
+        value.radians
+      else
+        value.to_f
+      end
+    end
+  end
+end

data/lib/rtanque/match.rb

@@ -0,0 +1,67 @@
+module RTanque
+  class Match
+    attr_reader :arena, :bots, :shells, :explosions, :ticks, :max_ticks
+
+    def initialize(arena, max_ticks = nil)
+      @arena = arena
+      @max_ticks = max_ticks
+      @ticks = 0
+      @shells = TickGroup.new
+      @bots = TickGroup.new
+      @explosions = TickGroup.new
+      @bots.pre_tick(&method(:pre_bot_tick))
+      @bots.post_tick(&method(:post_bot_tick))
+      @shells.pre_tick(&method(:pre_shell_tick))
+      @stopped = false
+    end
+
+    def max_ticks_reached?
+      self.max_ticks && self.ticks >= self.max_ticks
+    end
+
+    def finished?
+      @stopped || self.max_ticks_reached? || self.bots.count <= 1
+    end
+
+    def add_bots(*bots)
+      self.bots.add(*bots)
+    end
+
+    def start
+      self.tick until self.finished?
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def pre_bot_tick(bot)
+      bot.radar.scan(self.bots.all_but(bot))
+    end
+
+    def post_bot_tick(bot)
+      if bot.firing?
+        # shell starts life at the end of the turret
+        shell_position = bot.position.move(bot.turret.heading, RTanque::Bot::Turret::LENGTH)
+        @shells.add(RTanque::Shell.new(bot, shell_position, bot.turret.heading.clone, bot.fire_power))
+      end
+    end
+
+    def pre_shell_tick(shell)
+      shell.hits(self.bots.all_but(shell.bot)) do |origin_bot, bot_hit|
+        damage = (shell.fire_power ** RTanque::Shell::RATIO)
+        bot_hit.reduce_health(damage)
+        if bot_hit.dead?
+          @explosions.add(Explosion.new(bot_hit.position))
+        end
+      end
+    end
+
+    def tick
+      self.shells.tick
+      self.bots.tick
+      self.explosions.tick
+      @ticks += 1
+    end
+  end
+end

data/lib/rtanque/match/tick_group.rb

@@ -0,0 +1,50 @@
+module RTanque
+  class Match
+    class TickGroup
+      include Enumerable
+
+      def initialize
+        @members = []
+        @pre_tick = nil
+        @post_tick = nil
+      end
+
+      def each(&block)
+        @members.each(&block)
+      end
+
+      def all_but(*to_exclude)
+        self.reject { |member| to_exclude.include?(member) }
+      end
+
+      def delete_if(&block)
+        @members.delete_if(&block)
+      end
+
+      def add(*members)
+        @members += members.flatten
+      end
+
+      def pre_tick(&block)
+        @pre_tick = block
+      end
+
+      def post_tick(&block)
+        @post_tick = block
+      end
+
+      def tick
+        self.delete_if do |member|
+          if member.dead?
+            true
+          else
+            @pre_tick.call(member) if @pre_tick
+            member.tick
+            @post_tick.call(member) if @post_tick
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rtanque/movable.rb

@@ -0,0 +1,51 @@
+module RTanque
+  module Movable
+    def tick
+      update_position
+    end
+
+    def dead?
+      false # should overwrite
+    end
+
+    def arena
+      @arena
+    end
+
+    def arena=(val)
+      @arena = val
+    end
+
+    def position
+      @position
+    end
+
+    def position=(val)
+      @position = val
+    end
+
+    def bound_to_arena
+      true
+    end
+
+    def update_position
+      @position = @position.move(self.heading, self.speed, self.bound_to_arena)
+    end
+
+    def heading
+      @heading
+    end
+
+    def heading=(val)
+      @heading = Heading.new(val) if val
+    end
+
+    def speed
+      @speed
+    end
+
+    def speed=(val)
+      @speed = val if val
+    end
+  end
+end

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 = RTanque.round((self.x + (Math.sin(heading) * speed)), 10)
+      y = RTanque.round((self.y + (Math.cos(heading) * speed)), 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