colstrom-rtanque 0.1.3

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,37 @@
+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)
+        if self.class.const_defined?(:Gosu)
+          button_id = Gosu::Window.char_to_button_id(button_id) unless button_id.kind_of?(Integer)
+          @gui_window && @gui_window.button_down?(button_id)
+        else
+          false
+        end
+      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,47 @@
+require 'configuration'
+
+module RTanque
+  one_degree = (Math::PI / 180.0)
+
+  # @!visibility private
+  Configuration = ::Configuration.for('default') do
+    raise_brain_tick_errors true
+    quit_when_finished 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,25 @@
+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_HEALTH = 5
+      BOT_NAME = 6
+      BOT_BODY = 7
+      BOT_TURRET = 8
+      BOT_RADAR = 9
+      SHELL = 10
+      EXPLOSION = 20
+    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,71 @@
+require 'gosu'
+require 'texplay'
+
+require 'rtanque/gui/bot/health_color_calculator'
+
+module RTanque
+  module Gui
+    class Bot
+      attr_reader :bot
+
+      HEALTH_BAR_HEIGHT = 3
+      HEALTH_BAR_WIDTH = 100
+
+      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"))
+        @score_bar_image = TexPlay.create_blank_image(@window, HEALTH_BAR_WIDTH, HEALTH_BAR_HEIGHT)
+        @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)
+        draw_health(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
+
+      def draw_health(position)
+        x,y = *position
+        x_health = health.round(0)
+        health_color = color_for_health
+        @score_bar_image.paint {
+          rect 0, 0, HEALTH_BAR_WIDTH, HEALTH_BAR_HEIGHT, :color => [0,0,0,0], :fill => true
+          rect 0, 0, x_health, HEALTH_BAR_HEIGHT, :color => health_color, :fill => true
+        }
+        @score_bar_image.draw(x - (HEALTH_BAR_WIDTH/2) * @x_factor, y + (5 + RTanque::Bot::RADIUS) * @y_factor, ZOrder::BOT_HEALTH, @x_factor, @y_factor)
+      end
+
+      private
+
+      def color_for_health
+        HealthColorCalculator.new(health).color_as_rgb
+      end
+
+      def health
+        self.bot.health
+      end
+    end
+  end
+end

data/lib/rtanque/gui/bot/health_color_calculator.rb

@@ -0,0 +1,37 @@
+module RTanque
+  module Gui
+    class Bot
+      class HealthColorCalculator
+
+        # different health-clors as RGB values
+        FULL_HEALTH_COLOR   = [ 74, 190,  74].map { |v| v/255.0 }
+        MEDIUM_HEALTH_COLOR = [255, 190,   0].map { |v| v/255.0 }
+        LOW_HEALTH_COLOR    = [220,   0,   0].map { |v| v/255.0 }
+
+        attr_reader :health
+
+        def initialize(health)
+          @health = health
+        end
+
+        def color_as_rgb
+          if health > 50
+            percentage = ((100 - health) / 50)
+            color_between FULL_HEALTH_COLOR, MEDIUM_HEALTH_COLOR, percentage
+          else
+            percentage = ((50 - health) / 50)
+            color_between MEDIUM_HEALTH_COLOR, LOW_HEALTH_COLOR, percentage
+          end
+        end
+
+        def color_between(color_a, color_b, percentage)
+          [
+            (color_b[0] - color_a[0]) * percentage + color_a[0],
+            (color_b[1] - color_a[1]) * percentage + color_a[1],
+            (color_b[2] - color_a[2]) * percentage + color_a[2]
+          ]
+        end
+      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