colstrom-rtanque 0.1.3

data/lib/rtanque/gui/explosion.rb

@@ -0,0 +1,25 @@
+require 'gosu'
+
+module RTanque
+  module Gui
+    class Explosion
+      FRAMES = (1..71)
+
+      def initialize(window, explosion)
+        @window = window
+        @explosion = explosion
+        @position = [explosion.position.x, window.height - explosion.position.y]
+        @explosion_images = FRAMES.map { |i| Gosu::Image.new(@window, Gui.resource_path("images/explosions/explosion2-#{i}.png")) }
+      end
+
+      def draw
+        frame.draw_rot(@position[0], @position[1], 5, ZOrder::EXPLOSION)
+      end
+
+      def frame
+        @frames_length ||= @explosion_images.length - 1
+        @explosion_images[(@explosion.percent_dead * @frames_length).floor]
+      end
+    end
+  end
+end

data/lib/rtanque/gui/shell.rb

@@ -0,0 +1,31 @@
+require 'gosu'
+
+module RTanque
+  module Gui
+    class Shell
+      attr_reader :shell
+
+      DEBUG = ENV["DEBUG_SHELLS"]
+
+      def initialize(window, shell)
+        @window = window
+        @shell = shell
+        @x0 = shell.position.x
+        @y0 = @window.height - shell.position.y
+        @shell_image = Gosu::Image.new(@window, Gui.resource_path("images/bullet.png"))
+      end
+
+      def draw
+        position = [self.shell.position.x, @window.height - self.shell.position.y]
+        @shell_image.draw_rot(position[0], position[1], ZOrder::SHELL, 0, 0.5, 0.5)
+
+        if DEBUG then
+          white  = Gosu::Color::WHITE
+          pos = shell.position
+          x1, y1 = pos.x, @window.height - pos.y
+          @window.draw_line @x0, @y0, white, x1, y1, white, ZOrder::SHELL
+        end
+      end
+    end
+  end
+end

data/lib/rtanque/gui/window.rb

@@ -0,0 +1,64 @@
+require 'gosu'
+
+module RTanque
+  module Gui
+    class Window < Gosu::Window
+      UPDATE_INTERVAL = Configuration.gui.update_interval
+      FONT_NAME = Gosu::default_font_name
+      SMALL_FONT_SIZE = Configuration.gui.fonts.small
+
+      attr_reader :gui_bots, :gui_shells, :gui_explosions
+
+      def initialize(match)
+        @match = match
+        @arena = match.arena
+        match.bots.each { |bot| bot.gui_window = self }
+        @gui_bots = DrawGroup.new(match.bots) do |bot|
+          RTanque::Gui::Bot.new(self, bot)
+        end
+        @gui_shells = DrawGroup.new(match.shells) do |shell|
+          RTanque::Gui::Shell.new(self, shell)
+        end
+        @gui_explosions = DrawGroup.new(match.explosions) do |explosion|
+          RTanque::Gui::Explosion.new(self, explosion)
+        end
+        # Fullscreen: https://github.com/jlnr/gosu/issues/159#issuecomment-12473172
+        super(@arena.width, @arena.height, false, UPDATE_INTERVAL)
+        self.caption = self.class.name.split('::').first
+        @background = Gosu::Image.new(self, Gui.resource_path("images/grass.png"))
+
+        @draw_procs = []
+      end
+
+      def update
+        @match.tick
+      end
+
+      def draw
+        self.close if button_down?(Gosu::Button::KbEscape)
+        @background.draw(0, 0, ZOrder::BACKGROUND)
+        if @match.finished?
+          self.close if Configuration.quit_when_finished
+          self.gui_bots.each { |bot| bot.grow(2) }
+        end
+        self.draw_drawables
+      end
+
+      def draw_drawables
+        self.gui_bots.draw
+        self.gui_shells.draw
+        self.gui_explosions.draw
+
+        @draw_procs.each do |proc|
+          proc.call self
+        end
+
+        @draw_procs.clear
+      end
+
+      def add_draw_proc &b
+        @draw_procs << b
+      end
+    end
+  end
+end

data/lib/rtanque/heading.rb

@@ -0,0 +1,162 @@
+# -*- 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(Kernel.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 = radians.to_f % 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.to_f < self.to_f ? -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 + other_heading.to_f)
+    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 * other_heading.to_f)
+    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
+  end
+end

data/lib/rtanque/match.rb

@@ -0,0 +1,73 @@
+module RTanque
+  class Match
+    attr_reader :arena, :bots, :shells, :explosions, :ticks, :max_ticks, :teams
+
+    def initialize(arena, max_ticks = nil, teams = false)
+      @arena = arena
+      @max_ticks = max_ticks
+      @teams = teams
+      @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 teams=(bool)
+      @teams = bool
+    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 ||
+        (self.teams && self.bots.map(&:name).uniq.size == 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.to_a - to_exclude
+      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