tank_island 1.0.0

data/lib/entities/components/player_input.rb

@@ -0,0 +1,100 @@
+class PlayerInput < Component
+  # Dark green
+  NAME_COLOR = Gosu::Color.argb(0xee084408)
+  attr_reader :stats
+
+  def initialize(name, camera, object_pool)
+    super(nil)
+    @name = name
+    @stats = Stats.new(name)
+    @camera = camera
+    @object_pool = object_pool
+  end
+
+  def control(obj)
+    self.object = obj
+    obj.components << self
+  end
+
+  def on_collision(with)
+  end
+
+  def on_damage(amount)
+    @stats.add_damage(amount)
+  end
+
+  def update
+    return respawn if object.health.dead?
+    d_x, d_y = @camera.target_delta_on_screen
+    atan = Math.atan2(($window.width / 2) - d_x - $window.mouse_x,
+                      ($window.height / 2) - d_y - $window.mouse_y)
+    object.gun_angle = -atan * 180 / Math::PI
+    motion_buttons = [Gosu::KbW, Gosu::KbS, Gosu::KbA, Gosu::KbD]
+
+    if any_button_down?(*motion_buttons)
+      object.throttle_down = true
+      object.physics.change_direction(
+        change_angle(object.direction, *motion_buttons))
+    else
+      object.throttle_down = false
+    end
+
+    if Utils.button_down?(Gosu::MsLeft)
+      object.shoot(*@camera.mouse_coords)
+    end
+  end
+
+  def 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)
+      @camera.x, @camera.y = x, y
+      PlayerSounds.respawn(object, @camera)
+    end
+  end
+
+  def any_button_down?(*buttons)
+    buttons.each do |b|
+      return true if Utils.button_down?(b)
+    end
+    false
+  end
+
+  def change_angle(previous_angle, up, down, right, left)
+    if Utils.button_down?(up)
+      angle = 0.0
+      angle += 45.0 if Utils.button_down?(left)
+      angle -= 45.0 if Utils.button_down?(right)
+    elsif Utils.button_down?(down)
+      angle = 180.0
+      angle -= 45.0 if Utils.button_down?(left)
+      angle += 45.0 if Utils.button_down?(right)
+    elsif Utils.button_down?(left)
+      angle = 90.0
+      angle += 45.0 if Utils.button_down?(up)
+      angle -= 45.0 if Utils.button_down?(down)
+    elsif Utils.button_down?(right)
+      angle = 270.0
+      angle -= 45.0 if Utils.button_down?(up)
+      angle += 45.0 if Utils.button_down?(down)
+    end
+    angle = (angle + 360) % 360 if angle && angle < 0
+    (angle || previous_angle)
+  end
+
+end

data/lib/entities/components/player_sounds.rb

@@ -0,0 +1,16 @@
+class PlayerSounds
+  class << self
+    def respawn(object, camera)
+      volume, pan = Utils.volume_and_pan(object, camera)
+      respawn_sound.play(object.object_id, pan, volume * 0.5)
+    end
+
+    private
+
+    def respawn_sound
+      @@respawn ||= StereoSample.new(
+        $window, Utils.media_path('respawn.wav'))
+    end
+  end
+end
+

data/lib/entities/components/powerup_graphics.rb

@@ -0,0 +1,22 @@
+class PowerupGraphics < Component
+  def initialize(object, type)
+    super(object)
+    @type = type
+  end
+
+  def draw(viewport)
+    image.draw(x - 12, y - 12, 1)
+    Utils.mark_corners(object.box) if $debug
+  end
+
+  private
+
+  def image
+    @image ||= images.frame("#{@type}.png")
+  end
+
+  def images
+    @@images ||= Gosu::TexturePacker.load_json(
+      $window, Utils.media_path('pickups.json'))
+  end
+end

data/lib/entities/components/powerup_sounds.rb

@@ -0,0 +1,15 @@
+class PowerupSounds
+  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('powerup.mp3'))
+    end
+  end
+end

data/lib/entities/components/tank_graphics.rb

@@ -0,0 +1,46 @@
+class TankGraphics < Component
+  def initialize(game_object)
+    super(game_object)
+    @body_normal = units.frame('tank1_body.png')
+    @shadow_normal = units.frame('tank1_body_shadow.png')
+    @gun_normal = units.frame('tank1_dualgun.png')
+    @body_dead = units.frame('tank1_body_destroyed.png')
+    @shadow_dead = units.frame('tank1_body_destroyed_shadow.png')
+    @gun_dead = nil
+    update
+  end
+
+  def update
+    if object && object.health.dead?
+      @body = @body_dead
+      @gun = @gun_dead
+      @shadow = @shadow_dead
+    else
+      @body = @body_normal
+      @gun = @gun_normal
+      @shadow = @shadow_normal
+    end
+  end
+
+  def draw(viewport)
+    @shadow.draw_rot(x - 1, y - 1, 0, object.direction)
+    @body.draw_rot(x, y, 1, object.direction)
+    @gun.draw_rot(x, y, 2, object.gun_angle) if @gun
+    Utils.mark_corners(object.box) if $debug
+  end
+
+  def width
+    @body.width
+  end
+
+  def height
+    @body.height
+  end
+
+  private
+
+  def units
+    @@units = Gosu::TexturePacker.load_json(
+      $window, Utils.media_path('ground_units.json'), :precise)
+  end
+end

data/lib/entities/components/tank_health.rb

@@ -0,0 +1,32 @@
+class TankHealth < Health
+  RESPAWN_DELAY = 5000
+  attr_accessor :health
+
+  def initialize(object, object_pool)
+    super(object, object_pool, 100, true)
+  end
+
+  def should_respawn?
+    if @death_time
+      Gosu.milliseconds - @death_time > RESPAWN_DELAY
+    end
+  end
+
+  protected
+
+  def draw?
+    true
+  end
+
+  def after_death(cause)
+    @death_time = Gosu.milliseconds
+    object.reset_modifiers
+    object.input.stats.add_death
+    kill = object != cause ? 1 : -1
+    cause.input.stats.add_kill(kill)
+    Thread.new do
+      sleep(rand(0.1..0.3))
+      Explosion.new(@object_pool, x, y, cause)
+    end
+  end
+end

data/lib/entities/components/tank_physics.rb

@@ -0,0 +1,179 @@
+class TankPhysics < Component
+  attr_accessor :speed, :in_collision, :collides_with
+
+  def initialize(game_object, object_pool)
+    super(game_object)
+    @object_pool = object_pool
+    @map = object_pool.map
+    @speed = 0.0
+  end
+
+  def can_move_to?(x, y)
+    old_x, old_y = object.x, object.y
+    object.move(x, y)
+    return false unless @map.can_move_to?(x, y)
+    @object_pool.nearby(object, 100).each do |obj|
+      next if obj.class == Bullet && obj.source == object
+      if collides_with_poly?(obj.box)
+        if obj.is_a? Powerup
+          obj.on_collision(object)
+        else
+          @collides_with = obj
+          # Allow to get unstuck
+          old_distance = Utils.distance_between(
+            obj.x, obj.y, old_x, old_y)
+          new_distance = Utils.distance_between(
+            obj.x, obj.y, x, y)
+          return false if new_distance < old_distance
+        end
+      else
+        @collides_with = nil
+      end
+    end
+    true
+  ensure
+    object.move(old_x, old_y)
+  end
+
+  def change_direction(new_direction)
+    change = (new_direction - object.direction + 360) % 360
+    change = 360 - change if change > 180
+    if change > 90
+      @speed = 0
+    elsif change > 45
+      @speed *= 0.33
+    elsif change > 0
+      @speed *= 0.66
+    end
+    object.direction = new_direction % 360
+  end
+
+  def moving?
+    @speed > 0
+  end
+
+  def box_height
+    @box_height ||= object.graphics.height
+  end
+
+  def box_width
+    @box_width ||= object.graphics.width
+  end
+
+  # Tank box looks like H. Vertices:
+  # 1   2   5   6
+  #     3   4
+  #
+  #    10   9
+  # 12 11   8   7
+  def box
+    w = box_width / 2 - 1
+    h = box_height / 2 - 1
+    tw = 8 # track width
+    fd = 8 # front depth
+    rd = 6 # rear depth
+    Utils.rotate(object.direction, x, y,
+                 x + w,      y + h,      #1
+                 x + w - tw, y + h,      #2
+                 x + w - tw, y + h - fd, #3
+
+                 x - w + tw, y + h - fd, #4
+                 x - w + tw, y + h,      #5
+                 x - w,      y + h,      #6
+
+                 x - w,      y - h,      #7
+                 x - w + tw, y - h,      #8
+                 x - w + tw, y - h + rd, #9
+
+                 x + w - tw, y - h + rd, #10
+                 x + w - tw, y - h,      #11
+                 x + w,      y - h,      #12
+                )
+  end
+
+  def update
+    if object.throttle_down && !object.health.dead?
+      accelerate
+    else
+      decelerate
+    end
+    if @speed > 0
+      new_x, new_y = x, y
+      speed = apply_movement_penalty(@speed)
+      shift = Utils.adjust_speed(speed) * object.speed_modifier
+      case @object.direction.to_i
+      when 0
+        new_y -= shift
+      when 45
+        new_x += shift
+        new_y -= shift
+      when 90
+        new_x += shift
+      when 135
+        new_x += shift
+        new_y += shift
+      when 180
+        new_y += shift
+      when 225
+        new_y += shift
+        new_x -= shift
+      when 270
+        new_x -= shift
+      when 315
+        new_x -= shift
+        new_y -= shift
+      end
+      if can_move_to?(new_x, new_y)
+        object.move(new_x, new_y)
+        @in_collision = false
+      else
+        object.on_collision(@collides_with)
+        @speed = 0.0
+        @in_collision = true
+      end
+    end
+  end
+
+  private
+
+  def apply_movement_penalty(speed)
+    speed * (1.0 - @map.movement_penalty(x, y))
+  end
+
+  def accelerate
+    @speed += 0.08 if @speed < 5
+  end
+
+  def decelerate
+    if @speed > 0
+      @speed = [@speed - 0.5, 0].max
+    elsif @speed < 0
+      @speed = [@speed + 0.5, 0].min
+    end
+    damp_speed
+  end
+
+  def damp_speed
+    @speed = 0 if @speed < 0.01
+  end
+
+  def collides_with_poly?(poly)
+    if poly
+      if poly.size == 2
+        px, py = poly
+        return Utils.point_in_poly(px, py, *box)
+      end
+      poly.each_slice(2) do |x, y|
+        return true if Utils.point_in_poly(x, y, *box)
+      end
+      box.each_slice(2) do |x, y|
+        return true if Utils.point_in_poly(x, y, *poly)
+      end
+    end
+    false
+  end
+
+  def collides_with_point?(x, y)
+    Utils.point_in_poly(x, y, box)
+  end
+end

data/lib/entities/components/tank_sounds.rb

@@ -0,0 +1,43 @@
+class TankSounds < Component
+  def initialize(object, object_pool)
+    super(object)
+    @object_pool = object_pool
+  end
+
+  def update
+    id = object.object_id
+    if object.physics.moving?
+      move_volume = Utils.volume(
+        object, @object_pool.camera)
+      pan = Utils.pan(object, @object_pool.camera)
+      if driving_sound.paused?(id)
+        driving_sound.resume(id)
+      elsif driving_sound.stopped?(id)
+        driving_sound.play(id, pan, 0.5, 1, true)
+      end
+      driving_sound.volume_and_pan(id, move_volume * 0.5, pan)
+    else
+      if driving_sound.playing?(id)
+        driving_sound.pause(id)
+      end
+    end
+  end
+
+  def collide
+    vol, pan = Utils.volume_and_pan(
+      object, @object_pool.camera)
+    crash_sound.play(self.object_id, pan, vol, 1, false)
+  end
+
+  private
+
+  def driving_sound
+    @@driving_sound ||= StereoSample.new(
+      $window, Utils.media_path('tank_driving.mp3'))
+  end
+
+  def crash_sound
+    @@crash_sound ||= StereoSample.new(
+      $window, Utils.media_path('metal_interaction2.wav'))
+  end
+end