rtanque 0.0.2

data/lib/rtanque/bot/brain.rb

@@ -0,0 +1,50 @@
+module RTanque
+  class Bot
+    # Commands the associated {RTanque::Bot}. This class should be inherited from and {NAME} and {#tick!} overridden.
+    #
+    # See {RTanque::Bot::BrainHelper} for a useful mixin
+    #
+    # Sample bots:
+    #
+    #  * {file:sample_bots/seek_and_destroy.rb SeekAndDestroy}
+    #  * {file:sample_bots/camper.rb Camper}
+    #  * {file:sample_bots/keyboard.rb Keyboard} Special bot controlled by the keyboard
+    #
+    class Brain
+      # Bot's display name
+      # @!parse NAME = 'bot name'
+
+      # @!attribute [r] sensors
+      #   @return [RTanque::Bot::Sensors]
+      # @!attribute [r] command
+      #   @return [RTanque::Bot::Command]
+      attr_accessor :sensors, :command
+      # @return [RTanque::Arena]
+      attr_reader :arena
+
+      # @!visibility private
+      def initialize(arena)
+        @arena = arena
+      end
+
+      # @!visibility private
+      def tick(sensors)
+        self.sensors = sensors
+        RTanque::Bot::Command.new.tap do |empty_command|
+          self.command = empty_command
+          self.tick!
+        end
+      end
+
+      # Main logic goes here
+      #
+      # Get input from {#sensors}. See {RTanque::Bot::Sensors}
+      #
+      # Give output to {#command}. See {RTanque::Bot::Command}
+      # @abstract
+      def tick!
+        # Sweet bot logic
+      end
+    end
+  end
+end

data/lib/rtanque/bot/brain_helper.rb

@@ -0,0 +1,23 @@
+module RTanque
+  class Bot
+    # Some helpful constants and methods for use as mixin in {RTanque::Bot::Brain}
+    module BrainHelper
+      BOT_RADIUS          = Bot::RADIUS
+      MAX_FIRE_POWER      = Bot::MAX_FIRE_POWER
+      MIN_FIRE_POWER      = Bot::MIN_FIRE_POWER
+      MAX_HEALTH          = Bot::MAX_HEALTH
+      MAX_BOT_SPEED       = Bot::MAX_SPEED
+      MAX_BOT_ROTATION    = Configuration.bot.turn_step
+      MAX_TURRET_ROTATION = Configuration.turret.turn_step
+      MAX_RADAR_ROTATION  = Configuration.radar.turn_step
+
+      # Run block every 'num_of_ticks'
+      # @param [Integer] num_of_ticks tick interval at which to execute block
+      # @yield
+      # @return [void]
+      def at_tick_interval(num_of_ticks)
+        yield if sensors.ticks % num_of_ticks == 0
+      end
+    end
+  end
+end

data/lib/rtanque/bot/command.rb

@@ -0,0 +1,23 @@
+module RTanque
+  class Bot
+    # Command provide output from the {RTanque::Bot::Brain} about the current state of the {RTanque::Match}
+    #
+    # They are made available to {RTanque::Bot::Brain} via {RTanque::Bot::Brain#command}
+    #
+    # All values are bound. Setting an out-of-bounds value will result in it being set to the max/min allowed value.
+    #
+    # @attr_writer [Float] speed
+    # @attr_writer [Float, RTanque::Heading] heading
+    # @attr_writer [Float, RTanque::Heading] radar_heading
+    # @attr_writer [Float, RTanque::Heading] turret_heading
+    # @attr_writer [Float, nil] fire_power sets firing power. Setting to nil will stop firing. See {#fire}
+    #
+    # @param [Float] power alias to {#fire_power=}
+    # @!method fire(power)
+    Command = Struct.new(:speed, :heading, :radar_heading, :turret_heading, :fire_power) do
+      def fire(power = 3)
+        self.fire_power = power
+      end
+    end
+  end
+end

data/lib/rtanque/bot/radar.rb

@@ -0,0 +1,54 @@
+module RTanque
+  class Bot
+    class Radar
+      include Enumerable
+      include Movable
+      extend NormalizedAttr
+      VISION_RANGE = Configuration.radar.vision
+      attr_normalized(:heading, Heading::FULL_RANGE, Configuration.radar.turn_step)
+
+      # A Reflection is the information obtained for a bot detected by {RTanque::Bot::Radar}
+      #
+      # @attr_reader [RTanque::Heading] heading
+      # @attr_reader [Float] distance
+      # @attr_reader [String] name
+      Reflection = Struct.new(:heading, :distance, :name) do
+        def self.new_from_points(from_position, to_position, &tap)
+          self.new(from_position.heading(to_position), from_position.distance(to_position)).tap(&tap)
+        end
+      end
+
+      def initialize(bot, heading)
+        @bot = bot
+        @heading = heading
+        @reflections = []
+      end
+
+      def position
+        @bot.position
+      end
+
+      def each(&block)
+        @reflections.each(&block)
+      end
+
+      def empty?
+        self.count == 0
+      end
+
+      def scan(bots)
+        @reflections.clear
+        bots.each do |other_bot|
+          if self.can_detect?(other_bot)
+            @reflections << Reflection.new_from_points(self.position, other_bot.position) { |reflection| reflection.name = other_bot.name }
+          end
+        end
+        self
+      end
+
+      def can_detect?(other_bot)
+        VISION_RANGE.include?(Heading.delta_between_points(self.position, self.heading, other_bot.position))
+      end
+    end
+  end
+end

data/lib/rtanque/bot/sensors.rb

@@ -0,0 +1,33 @@
+module RTanque
+  class Bot
+    # Sensors provide input to the {RTanque::Bot::Brain} about the current state of the {RTanque::Match}
+    #
+    # They are made available to {RTanque::Bot::Brain} via {RTanque::Bot::Brain#sensors}
+    #
+    # @attr_reader [Integer] ticks number of ticks, starts at 0
+    # @attr_reader [Float] health health of bot. if == 0, dead
+    # @attr_reader [Float] gun_energy energy of cannon. if < 0, cannot fire
+    # @attr_reader [Float] speed
+    # @attr_reader [RTanque::Point] position
+    # @attr_reader [RTanque::Heading] heading
+    # @attr_reader [RTanque::Heading] radar_heading
+    # @attr_reader [RTanque::Heading] turret_heading
+    # @attr_reader [Enumerator] radar enumerates all bots scanned by the radar, yielding {RTanque::Bot::Radar::Reflection}
+    Sensors = Struct.new(:ticks, :health, :speed, :position, :heading, :radar, :radar_heading, :turret_heading, :gun_energy) do
+      def initialize(*args, &block)
+        super(*args)
+        block.call(self) if block
+        self.freeze
+      end
+
+      def button_down?(button_id)
+        button_id = Gosu::Window.char_to_button_id(button_id) unless button_id.kind_of?(Integer)
+        @gui_window && @gui_window.button_down?(button_id)
+      end
+
+      def gui_window=(gui_window)
+        @gui_window = gui_window
+      end
+    end
+  end
+end

data/lib/rtanque/bot/turret.rb

@@ -0,0 +1,14 @@
+module RTanque
+  class Bot
+    class Turret
+      include Movable
+      extend NormalizedAttr
+      LENGTH = Configuration.turret.length
+      attr_normalized(:heading, Heading::FULL_RANGE, Configuration.turret.turn_step)
+
+      def initialize(heading)
+        @heading = heading
+      end
+    end
+  end
+end

data/lib/rtanque/configuration.rb

@@ -0,0 +1,46 @@
+require 'configuration'
+
+module RTanque
+  one_degree = (Math::PI / 180.0)
+
+  # @!visibility private
+  Configuration = ::Configuration.for('default') do
+    raise_brain_tick_errors true
+
+    bot do
+      radius 19
+      health_reduction_on_exception 2
+      health 0..100
+      speed -3..3
+      speed_step 0.05
+      turn_step one_degree * 1.5
+      fire_power 1..5
+      gun_energy_max 10
+      gun_energy_factor 10
+    end
+    turret do
+      length 28
+      turn_step (one_degree * 2.0)
+    end
+    radar do
+      turn_step 0.05
+      vision -(one_degree * 10.0)..(one_degree * 10.0)
+    end
+    shell do
+      speed_factor 4.5
+      ratio 1.5 # used by Bot#adjust_fire_power and to calculate damage done by shell to bot
+    end
+    explosion do
+      life_span 70 * 1 # should be multiple of the number of frames in the explosion animation
+    end
+    gui do
+      update_interval 16.666666 # in milliseconds. 16.666666 == 60 FPS
+      fonts do
+        small 16
+      end
+    end
+  end
+  def Configuration.config(&block)
+    ::Configuration::DSL.evaluate(self, &block)
+  end
+end

data/lib/rtanque/explosion.rb

@@ -0,0 +1,23 @@
+module RTanque
+  class Explosion
+    include Movable
+    attr_reader :position
+    LIFE_SPAN = Configuration.explosion.life_span # ticks
+    def initialize(position)
+      @position = position
+      @ticks = 0
+    end
+
+    def percent_dead
+      @ticks / LIFE_SPAN.to_f
+    end
+
+    def tick
+      @ticks += 1
+    end
+
+    def dead?
+      @ticks > LIFE_SPAN
+    end
+  end
+end

data/lib/rtanque/gui.rb

@@ -0,0 +1,24 @@
+module RTanque
+  module Gui
+    RESOURCE_DIR = File.expand_path('../../../resources', __FILE__)
+    def self.resource_path(*components)
+      File.join(RESOURCE_DIR, *components)
+    end
+
+    module ZOrder
+      BACKGROUND = -1
+      BOT_NAME = 0
+      BOT_BODY = 1
+      BOT_TURRET = 2
+      BOT_RADAR = 3
+      SHELL = 4
+      EXPLOSION = 10
+    end
+  end
+end
+
+require 'rtanque/gui/draw_group'
+require 'rtanque/gui/window'
+require 'rtanque/gui/bot'
+require 'rtanque/gui/shell'
+require 'rtanque/gui/explosion'

data/lib/rtanque/gui/bot.rb

@@ -0,0 +1,42 @@
+require 'gosu'
+
+module RTanque
+  module Gui
+    class Bot
+      attr_reader :bot
+
+      def initialize(window, bot)
+        @window = window
+        @bot = bot
+        @body_image = Gosu::Image.new(@window, Gui.resource_path("images/body.png"))
+        @turret_image = Gosu::Image.new(@window, Gui.resource_path("images/turret.png"))
+        @radar_image = Gosu::Image.new(@window, Gui.resource_path("images/radar.png"))
+        @name_font = Gosu::Font.new(@window, Window::FONT_NAME, Window::SMALL_FONT_SIZE)
+        @x_factor = 1
+        @y_factor = 1
+      end
+
+      def draw
+        position = [@bot.position.x, @window.height - @bot.position.y]
+        draw_bot(position)
+        draw_name(position)
+      end
+
+      def grow(factor = 2, step = 0.002)
+        @x_factor += step unless @x_factor > factor
+        @y_factor += step unless @y_factor > factor
+      end
+
+      def draw_bot(position)
+        @body_image.draw_rot(position[0], position[1], ZOrder::BOT_BODY, Gosu.radians_to_degrees(@bot.heading.to_f), 0.5, 0.5, @x_factor, @y_factor)
+        @turret_image.draw_rot(position[0], position[1], ZOrder::BOT_TURRET, Gosu.radians_to_degrees(@bot.turret.heading.to_f), 0.5, 0.5, @x_factor, @y_factor)
+        @radar_image.draw_rot(position[0], position[1], ZOrder::BOT_RADAR, Gosu.radians_to_degrees(@bot.radar.heading.to_f), 0.5, 0.5, @x_factor, @y_factor)
+      end
+
+      def draw_name(position)
+        x,y = *position
+        @name_font.draw_rel(self.bot.name, x, y + (RTanque::Bot::RADIUS * @y_factor) + Window::SMALL_FONT_SIZE.to_i, ZOrder::BOT_NAME, 0.5, 0.5, @x_factor, @y_factor)
+      end
+    end
+  end
+end

data/lib/rtanque/gui/draw_group.rb

@@ -0,0 +1,30 @@
+module RTanque
+  module Gui
+    class DrawGroup
+      include Enumerable
+
+      def initialize(tick_group, &create_drawable)
+        @tick_group = tick_group
+        @mapped_drawables = Hash.new do |h, tickable|
+          h[tickable] = create_drawable.call(tickable)
+        end
+      end
+
+      def each(&block)
+        @tick_group.each do |tickable|
+          if tickable.dead?
+            @mapped_drawables.delete(tickable)
+          else
+            block.call(@mapped_drawables[tickable]) # This invokes @mapped_drawables's block if tickable not already in the hash
+          end
+        end
+      end
+
+      def draw
+        self.each do |drawable|
+          drawable.draw
+        end
+      end
+    end
+  end
+end

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,20 @@
+require 'gosu'
+
+module RTanque
+  module Gui
+    class Shell
+      attr_reader :shell
+
+      def initialize(window, shell)
+        @window = window
+        @shell = shell
+        @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)
+      end
+    end
+  end
+end

data/lib/rtanque/gui/window.rb

@@ -0,0 +1,51 @@
+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"))
+      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.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
+      end
+    end
+  end
+end