tank_island 1.0.0

data/lib/entities/components/ai/vision.rb

@@ -0,0 +1,109 @@
+class AiVision
+  CACHE_TIMEOUT = 500
+  POWERUP_CACHE_TIMEOUT = 50
+  attr_reader :in_sight
+
+  def initialize(viewer, object_pool, distance)
+    @viewer = viewer
+    @object_pool = object_pool
+    @distance = distance
+  end
+
+  def can_go_forward?
+    in_front = Utils.point_at_distance(
+      *@viewer.location, @viewer.direction, 40)
+    @object_pool.map.can_move_to?(*in_front) &&
+      @object_pool.nearby_point(*in_front, 40, @viewer)
+        .reject { |o| o.is_a? Powerup }.empty?
+  end
+
+  def update
+    @in_sight = @object_pool.nearby(@viewer, @distance)
+  end
+
+  def closest_free_path(away_from = nil)
+    paths = []
+    5.times do |i|
+      if paths.any?
+        return farthest_from(paths, away_from)
+      end
+      radius = 55 - i * 5
+      range_x = range_y = [-radius, 0, radius]
+      range_x.shuffle.each do |x|
+        range_y.shuffle.each do |y|
+          x = @viewer.x + x
+          y = @viewer.y + y
+          if @object_pool.map.can_move_to?(x, y) &&
+              @object_pool.nearby_point(x, y, radius, @viewer)
+                .reject { |o| o.is_a? Powerup }.empty?
+            if away_from
+              paths << [x, y]
+            else
+              return [x, y]
+            end
+          end
+        end
+      end
+    end
+    false
+  end
+
+  alias :closest_free_path_away_from :closest_free_path
+
+  def closest_tank
+    now = Gosu.milliseconds
+    @closest_tank = nil
+    if now - (@cache_updated_at ||= 0) > CACHE_TIMEOUT
+      @closest_tank = nil
+      @cache_updated_at = now
+    end
+    @closest_tank ||= find_closest_tank
+  end
+
+  def closest_powerup(*suitable)
+    now = Gosu.milliseconds
+    @closest_powerup = nil
+    if now - (@powerup_cache_updated_at ||= 0) > POWERUP_CACHE_TIMEOUT
+      @closest_powerup = nil
+      @powerup_cache_updated_at = now
+    end
+    @closest_powerup ||= find_closest_powerup(*suitable)
+  end
+
+  private
+
+  def farthest_from(paths, away_from)
+    paths.sort do |p1, p2|
+      Utils.distance_between(*p1, *away_from) <=>
+        Utils.distance_between(*p2, *away_from)
+    end.first
+  end
+
+  def find_closest_powerup(*suitable)
+    if suitable.empty?
+      suitable = [FireRatePowerup,
+                  HealthPowerup,
+                  RepairPowerup,
+                  TankSpeedPowerup]
+    end
+    @in_sight.select do |o|
+      suitable.include?(o.class)
+    end.sort do |a, b|
+      x, y = @viewer.x, @viewer.y
+      d1 = Utils.distance_between(x, y, a.x, a.y)
+      d2 = Utils.distance_between(x, y, b.x, b.y)
+      d1 <=> d2
+    end.first
+  end
+
+  def find_closest_tank
+    @in_sight.select do |o|
+      o.class == Tank && !o.health.dead?
+    end.sort do |a, b|
+      x, y = @viewer.x, @viewer.y
+      d1 = Utils.distance_between(x, y, a.x, a.y)
+      d2 = Utils.distance_between(x, y, b.x, b.y)
+      d1 <=> d2
+    end.first
+  end
+end

data/lib/entities/components/ai_input.rb

@@ -0,0 +1,70 @@
+class AiInput < Component
+  # Dark red
+  NAME_COLOR = Gosu::Color.argb(0xeeb10000)
+  UPDATE_RATE = 10 # ms
+  attr_reader :name
+  attr_reader :stats
+
+  def initialize(name, object_pool)
+    super(nil)
+    @object_pool = object_pool
+    @stats = Stats.new(name)
+    @name = name
+    @last_update = Gosu.milliseconds
+  end
+
+  def control(obj)
+    self.object = obj
+    object.components << self
+    @vision = AiVision.new(obj, @object_pool,
+                           rand(700..1200))
+    @gun = AiGun.new(obj, @vision)
+    @motion = TankMotionFSM.new(obj, @vision, @gun)
+  end
+
+  def on_collision(with)
+    return if object.health.dead?
+    @motion.on_collision(with)
+  end
+
+  def on_damage(amount)
+    @motion.on_damage(amount)
+    @stats.add_damage(amount)
+  end
+
+  def update
+    return respawn if object.health.dead?
+    @gun.adjust_angle
+    now = Gosu.milliseconds
+    return if now - @last_update < UPDATE_RATE
+    @last_update = now
+    @vision.update
+    @gun.update
+    @motion.update
+  end
+
+  def draw(viewport)
+    @motion.draw(viewport)
+    @gun.draw(viewport)
+    @name_image ||= Gosu::Image.from_text(
+      $window, @name, Gosu.default_font_name, 20)
+    @name_image.draw(
+      x - @name_image.width / 2 - 1,
+      y + object.graphics.height / 2, 100,
+      1, 1, Gosu::Color::WHITE)
+    @name_image.draw(
+      x - @name_image.width / 2,
+      y + object.graphics.height / 2, 100,
+      1, 1, NAME_COLOR)
+  end
+
+  private
+
+  def respawn
+    if object.health.should_respawn?
+      object.health.restore
+      object.move(*@object_pool.map.spawn_point)
+      PlayerSounds.respawn(object, @object_pool.camera)
+    end
+  end
+end

data/lib/entities/components/box_graphics.rb

@@ -0,0 +1,39 @@
+class BoxGraphics < Component
+  def initialize(object)
+    super(object)
+    load_sprite
+  end
+
+  def draw(viewport)
+    @box.draw_rot(x, y, 0, object.angle)
+    Utils.mark_corners(object.box) if $debug
+  end
+
+  def height
+    @box.height
+  end
+
+  def width
+    @box.width
+  end
+
+  private
+
+  def load_sprite
+    frame = boxes.frame_list.sample
+    @box = boxes.frame(frame)
+  end
+
+  def center_x
+    @center_x ||= x - width / 2
+  end
+
+  def center_y
+    @center_y ||= y - height / 2
+  end
+
+  def boxes
+    @@boxes ||= Gosu::TexturePacker.load_json($window,
+      Utils.media_path('boxes_barrels.json'))
+  end
+end

data/lib/entities/components/bullet_graphics.rb

@@ -0,0 +1,13 @@
+class BulletGraphics < Component
+  def draw(viewport)
+    image.draw(x - 8, y - 8, 1)
+    Utils.mark_corners(object.box) if $debug
+  end
+
+  private
+
+  def image
+    @@bullet ||= Gosu::Image.new(
+      $window, Utils.media_path('bullet.png'), false)
+  end
+end

data/lib/entities/components/bullet_physics.rb

@@ -0,0 +1,65 @@
+class BulletPhysics < Component
+  START_DIST = 20
+  MAX_DIST = 500
+
+  def initialize(game_object, object_pool)
+    super(game_object)
+    x, y = point_at_distance(START_DIST)
+    object.move(x, y)
+    @object_pool = object_pool
+    if trajectory_length > MAX_DIST
+      object.target_x, object.target_y = point_at_distance(MAX_DIST)
+    end
+  end
+
+  def update
+    fly_speed = Utils.adjust_speed(object.speed)
+    now = Gosu.milliseconds
+    @last_update ||= object.fired_at
+    fly_distance = (now - @last_update) * 0.001 * fly_speed
+    object.move(*point_at_distance(fly_distance))
+    @last_update = now
+    check_hit
+    object.explode if arrived?
+  end
+
+  def trajectory_length
+    Utils.distance_between(object.target_x, object.target_y, x, y)
+  end
+
+  def point_at_distance(distance)
+    if distance > trajectory_length
+      return [object.target_x, object.target_y]
+    end
+    distance_factor = distance.to_f / trajectory_length
+    p_x = x + (object.target_x - x) * distance_factor
+    p_y = y + (object.target_y - y) * distance_factor
+    [p_x, p_y]
+  end
+
+  private
+
+  def check_hit
+    @object_pool.nearby(object, 50).each do |obj|
+      next if obj == object.source # Don't hit source tank
+      if obj.class == Tree
+        if Utils.distance_between(x, y, obj.x, obj.y) < 10
+          return do_hit(obj) if obj.respond_to?(:health)
+        end
+      elsif Utils.point_in_poly(x, y, *obj.box)
+        # Direct hit - extra damage
+        return do_hit(obj) if obj.respond_to?(:health)
+      end
+    end
+  end
+
+  def do_hit(obj)
+    obj.health.inflict_damage(20, object.source)
+    object.target_x = x
+    object.target_y = y
+  end
+
+  def arrived?
+    x == object.target_x && y == object.target_y
+  end
+end

data/lib/entities/components/bullet_sounds.rb

@@ -0,0 +1,15 @@
+class BulletSounds
+  class << self
+    def play(object, camera)
+      volume, pan = Utils.volume_and_pan(object, camera)
+      sound.play(object.object_id, pan, volume)
+    end
+
+    private
+
+    def sound
+      @@sound ||= StereoSample.new(
+        $window, Utils.media_path('fire.mp3'))
+    end
+  end
+end

data/lib/entities/components/component.rb

@@ -0,0 +1,32 @@
+class Component
+  attr_reader :object # better performance
+
+  def initialize(game_object = nil)
+    self.object = game_object
+  end
+
+  def update
+    # override
+  end
+
+  def draw(viewport)
+    # override
+  end
+
+  protected
+
+  def object=(obj)
+    if obj
+      @object = obj
+      obj.components << self
+    end
+  end
+
+  def x
+    @object.x
+  end
+
+  def y
+    @object.y
+  end
+end

data/lib/entities/components/damage_graphics.rb

@@ -0,0 +1,20 @@
+class DamageGraphics < Component
+  def initialize(object_pool)
+    super
+    @image = images.sample
+    @angle = rand(0..360)
+  end
+
+  def draw(viewport)
+    @image.draw_rot(x, y, 0, @angle)
+  end
+
+  private
+
+  def images
+    @@images ||= (1..4).map do |i|
+      Gosu::Image.new($window,
+        Utils.media_path("damage#{i}.png"), false)
+    end
+  end
+end

data/lib/entities/components/explosion_graphics.rb

@@ -0,0 +1,43 @@
+class ExplosionGraphics < Component
+  FRAME_DELAY = 16.66 # ms
+
+  def initialize(game_object)
+    super
+    @current_frame = 0
+  end
+
+  def draw(viewport)
+    image = current_frame
+    image.draw(
+      x - image.width / 2 + 3,
+      y - image.height / 2 - 35,
+      20)
+  end
+
+  def update
+    now = Gosu.milliseconds
+    delta = now - (@last_frame ||= now)
+    if delta > FRAME_DELAY
+      @last_frame = now
+    end
+    @current_frame += (delta / FRAME_DELAY).floor
+    object.mark_for_removal if done?
+  end
+
+  private
+
+  def current_frame
+    animation[@current_frame % animation.size]
+  end
+
+  def done?
+    @done ||= @current_frame >= animation.size
+  end
+
+  def animation
+    @@animation ||=
+    Gosu::Image.load_tiles(
+      $window, Utils.media_path('explosion.png'),
+      128, 128, false)
+  end
+end

data/lib/entities/components/explosion_sounds.rb

@@ -0,0 +1,16 @@
+class ExplosionSounds
+  class << self
+    def play(object, camera)
+      volume, pan = Utils.volume_and_pan(object, camera)
+      sound.play(object.object_id, pan, volume)
+    end
+
+    private
+
+    def sound
+      @@sound ||= StereoSample.new(
+        $window, Utils.media_path('explosion.mp3'))
+    end
+  end
+end
+

data/lib/entities/components/health.rb

@@ -0,0 +1,87 @@
+class Health < Component
+  attr_accessor :health
+
+  def initialize(object, object_pool, health, explodes)
+    super(object)
+    @explodes = explodes
+    @object_pool = object_pool
+    @initial_health = @health = health
+    @health_updated = true
+  end
+
+  def restore
+    @health = @initial_health
+    @health_updated = true
+  end
+
+  def increase(amount)
+    @health = [@health + 25, @initial_health * 2].min
+    @health_updated = true
+  end
+
+  def damaged?
+    @health < @initial_health
+  end
+
+  def dead?
+    @health < 1
+  end
+
+  def update
+    update_image
+  end
+
+  def inflict_damage(amount, cause)
+    if @health > 0
+      @health_updated = true
+      if object.respond_to?(:input)
+        object.input.stats.add_damage(amount)
+        # Don't count damage to trees and boxes
+        if cause.respond_to?(:input) && cause != object
+          cause.input.stats.add_damage_dealt(amount)
+        end
+      end
+      @health = [@health - amount.to_i, 0].max
+      after_death(cause) if dead?
+    end
+  end
+
+  def draw(viewport)
+    return unless draw?
+    @image && @image.draw(
+      x - @image.width / 2,
+      y - object.graphics.height / 2 -
+      @image.height, 100)
+  end
+
+  protected
+
+  def draw?
+    $debug
+  end
+
+  def update_image
+    return unless draw?
+    if @health_updated
+      text = @health.to_s
+      font_size = 18
+      @image = Gosu::Image.from_text(
+          $window, text,
+          Gosu.default_font_name, font_size)
+      @health_updated = false
+    end
+  end
+
+  def after_death(cause)
+    if @explodes
+      Thread.new do
+        sleep(rand(0.1..0.3))
+        Explosion.new(@object_pool, x, y, cause)
+        sleep 0.3
+        object.mark_for_removal
+      end
+    else
+      object.mark_for_removal
+    end
+  end
+end