tank_island 1.0.0

data/lib/entities/components/tree_graphics.rb

@@ -0,0 +1,69 @@
+class TreeGraphics < Component
+  SHAKE_TIME = 100
+  SHAKE_COOLDOWN = 200
+  SHAKE_DISTANCE = [2, 1, 0, -1, -2, -1, 0, 1, 0, -1, 0]
+  def initialize(object, seed)
+    super(object)
+    load_sprite(seed)
+  end
+
+  def shake(direction)
+    now = Gosu.milliseconds
+    return if @shake_start &&
+      now - @shake_start < SHAKE_TIME + SHAKE_COOLDOWN
+    @shake_start = now
+    @shake_direction = direction
+    @shaking = true
+  end
+
+  def adjust_shake(x, y, shaking_for)
+    elapsed = [shaking_for, SHAKE_TIME].min / SHAKE_TIME.to_f
+    frame = ((SHAKE_DISTANCE.length - 1) * elapsed).floor
+    distance = SHAKE_DISTANCE[frame]
+    Utils.point_at_distance(x, y, @shake_direction, distance)
+  end
+
+  def draw(viewport)
+    if @shaking
+      shaking_for = Gosu.milliseconds - @shake_start
+      shaking_x, shaking_y = adjust_shake(
+        center_x, center_y, shaking_for)
+      @tree.draw(shaking_x, shaking_y, 5)
+      if shaking_for >= SHAKE_TIME
+        @shaking = false
+      end
+    else
+      @tree.draw(center_x, center_y, 5)
+    end
+    Utils.mark_corners(object.box) if $debug
+  end
+
+  def height
+    @tree.height
+  end
+
+  def width
+    @tree.width
+  end
+
+  private
+
+  def load_sprite(seed)
+    frame_list = trees.frame_list
+    frame = frame_list[(frame_list.size * seed).round]
+    @tree = trees.frame(frame)
+  end
+
+  def center_x
+    @center_x ||= x - @tree.width / 2
+  end
+
+  def center_y
+    @center_y ||= y - @tree.height / 2
+  end
+
+  def trees
+    @@trees ||= Gosu::TexturePacker.load_json($window,
+      Utils.media_path('trees_packed.json'))
+  end
+end

data/lib/entities/damage.rb

@@ -0,0 +1,26 @@
+class Damage < GameObject
+  MAX_INSTANCES = 300
+  @@instances = []
+
+  def initialize(object_pool, x, y)
+    super
+    DamageGraphics.new(self)
+    track(self)
+  end
+
+  def effect?
+    true
+  end
+
+  private
+
+  def track(instance)
+    if @@instances.size < MAX_INSTANCES
+      @@instances << instance
+    else
+      out = @@instances.shift
+      out.mark_for_removal
+      @@instances << instance
+    end
+  end
+end

data/lib/entities/explosion.rb

@@ -0,0 +1,34 @@
+class Explosion < GameObject
+
+  def initialize(object_pool, x, y, source)
+    super(object_pool, x, y)
+    @source = source
+    @object_pool = object_pool
+    if @object_pool.map.can_move_to?(x, y)
+      Damage.new(@object_pool, x, y)
+    end
+    ExplosionGraphics.new(self)
+    ExplosionSounds.play(self, object_pool.camera)
+    inflict_damage
+  end
+
+  def effect?
+    true
+  end
+
+  def mark_for_removal
+    super
+  end
+
+  private
+
+  def inflict_damage
+    object_pool.nearby(self, 100).each do |obj|
+      if obj.respond_to?(:health)
+        obj.health.inflict_damage(
+          Math.sqrt(3 * 100 - Utils.distance_between(
+              obj.x, obj.y, @x, @y)), @source)
+      end
+    end
+  end
+end

data/lib/entities/game_object.rb

@@ -0,0 +1,54 @@
+class GameObject
+  attr_reader :x, :y, :location, :components
+  def initialize(object_pool, x, y)
+    @x, @y = x, y
+    @location = [x, y]
+    @components = []
+    @object_pool = object_pool
+    @object_pool.add(self)
+  end
+
+  def move(new_x, new_y)
+    return if new_x == @x && new_y == @y
+    @object_pool.tree_remove(self)
+    @x = new_x
+    @y = new_y
+    @location = [new_x, new_y]
+    @object_pool.tree_insert(self)
+  end
+
+  def update
+    @components.map(&:update)
+  end
+
+  def draw(viewport)
+    @components.each { |c| c.draw(viewport) }
+  end
+
+  def removable?
+    @removable
+  end
+
+  def mark_for_removal
+    @removable = true
+  end
+
+  def on_collision(object)
+  end
+
+  def effect?
+    false
+  end
+
+  def box
+  end
+
+  def collide
+  end
+
+  protected
+
+  def object_pool
+    @object_pool
+  end
+end

data/lib/entities/hud.rb

@@ -0,0 +1,79 @@
+class HUD
+  attr_accessor :active
+  def initialize(object_pool, tank)
+    @object_pool = object_pool
+    @tank = tank
+    @radar = Radar.new(@object_pool, tank)
+  end
+
+  def player=(tank)
+    @tank = tank
+    @radar.target = tank
+  end
+
+  def update
+    @radar.update
+  end
+
+  def health_image
+    if @health.nil? || @tank.health.health != @health
+      @health = @tank.health.health
+      @health_image = Gosu::Image.from_text(
+        $window, "Health: #{@health}", Utils.main_font, 20)
+    end
+    @health_image
+  end
+
+  def stats_image
+    stats = @tank.input.stats
+    if @stats_image.nil? || stats.changed_at <= Gosu.milliseconds
+      @stats_image = Gosu::Image.from_text(
+        $window, "Kills: #{stats.kills}", Utils.main_font, 20)
+    end
+    @stats_image
+  end
+
+  def fire_rate_image
+    if @tank.fire_rate_modifier > 1
+      if @fire_rate != @tank.fire_rate_modifier
+        @fire_rate = @tank.fire_rate_modifier
+        @fire_rate_image = Gosu::Image.from_text(
+          $window, "Fire rate: #{@fire_rate.round(2)}X",
+          Utils.main_font, 20)
+      end
+    else
+      @fire_rate_image = nil
+    end
+    @fire_rate_image
+  end
+
+  def speed_image
+    if @tank.speed_modifier > 1
+      if @speed != @tank.speed_modifier
+        @speed = @tank.speed_modifier
+        @speed_image = Gosu::Image.from_text(
+          $window, "Speed: #{@speed.round(2)}X",
+          Utils.main_font, 20)
+      end
+    else
+      @speed_image = nil
+    end
+    @speed_image
+  end
+
+  def draw
+    if @active
+      @object_pool.camera.draw_crosshair
+    end
+    @radar.draw
+    offset = 20
+    health_image.draw(20, offset, 1000)
+    stats_image.draw(20, offset += 30, 1000)
+    if fire_rate_image
+      fire_rate_image.draw(20, offset += 30, 1000)
+    end
+    if speed_image
+      speed_image.draw(20, offset += 30, 1000)
+    end
+  end
+end

data/lib/entities/map.rb

@@ -0,0 +1,183 @@
+class Map
+  MAP_WIDTH = 30
+  MAP_HEIGHT = 30
+  TILE_SIZE = 128
+
+  def self.bounding_box
+    center = [MAP_WIDTH * TILE_SIZE / 2,
+              MAP_HEIGHT * TILE_SIZE / 2]
+    half_dimension = [MAP_WIDTH * TILE_SIZE,
+                      MAP_HEIGHT * TILE_SIZE]
+    AxisAlignedBoundingBox.new(center, half_dimension)
+  end
+
+  def initialize(object_pool)
+    load_tiles
+    @object_pool = object_pool
+    object_pool.map = self
+    @map = generate_map
+    generate_trees
+    generate_boxes
+    generate_powerups
+  end
+
+  def spawn_points(max)
+    @spawn_points = (0..max).map do
+      find_spawn_point
+    end
+    @spawn_points_pointer = 0
+  end
+
+  def spawn_point
+    @spawn_points[(@spawn_points_pointer += 1) % @spawn_points.size]
+  end
+
+  def can_move_to?(x, y)
+    tile = tile_at(x, y)
+    tile && tile != @water
+  end
+
+  def movement_penalty(x, y)
+    tile = tile_at(x, y)
+    case tile
+    when @sand
+      0.33
+    else
+      0
+    end
+  end
+
+  def draw(viewport)
+    viewport = viewport.map { |p| p / TILE_SIZE }
+    x0, x1, y0, y1 = viewport.map(&:to_i)
+    (x0-1..x1).each do |x|
+      (y0-1..y1).each do |y|
+        row = @map[x]
+        map_x = x * TILE_SIZE
+        map_y = y * TILE_SIZE
+        if row
+          tile = @map[x][y]
+          if tile
+            tile.draw(map_x, map_y, 0)
+          else
+            @water.draw(map_x, map_y, 0)
+          end
+        else
+          @water.draw(map_x, map_y, 0)
+        end
+      end
+    end
+  end
+
+  private
+
+  def tile_at(x, y)
+    t_x = ((x / TILE_SIZE) % TILE_SIZE).floor
+    t_y = ((y / TILE_SIZE) % TILE_SIZE).floor
+    row = @map[t_x]
+    row ? row[t_y] : @water
+  end
+
+  def load_tiles
+    tiles = Gosu::Image.load_tiles(
+      $window, Utils.media_path('ground.png'),
+      128, 128, true)
+    @sand = tiles[0]
+    @grass = tiles[8]
+    @water = Gosu::Image.new(
+      $window, Utils.media_path('water.png'), true)
+  end
+
+  def generate_map
+    noises = Perlin::Noise.new(2)
+    contrast = Perlin::Curve.contrast(
+      Perlin::Curve::CUBIC, 2)
+    map = {}
+    MAP_WIDTH.times do |x|
+      map[x] = {}
+      MAP_HEIGHT.times do |y|
+        n = noises[x * 0.1, y * 0.1]
+        n = contrast.call(n)
+        map[x][y] = choose_tile(n)
+      end
+    end
+    map
+  end
+
+  def generate_trees
+    noises = Perlin::Noise.new(2)
+    contrast = Perlin::Curve.contrast(
+      Perlin::Curve::CUBIC, 2)
+    trees = 0
+    target_trees = rand(1500..1500)
+    while trees < target_trees do
+      x = rand(0..MAP_WIDTH * TILE_SIZE)
+      y = rand(0..MAP_HEIGHT * TILE_SIZE)
+      n = noises[x * 0.001, y * 0.001]
+      n = contrast.call(n)
+      if tile_at(x, y) == @grass && n > 0.5
+        Tree.new(@object_pool, x, y, n * 2 - 1)
+        trees += 1
+      end
+    end
+  end
+
+  def generate_boxes
+    boxes = 0
+    target_boxes = rand(50..200)
+    while boxes < target_boxes do
+      x = rand(0..MAP_WIDTH * TILE_SIZE)
+      y = rand(0..MAP_HEIGHT * TILE_SIZE)
+      if tile_at(x, y) != @water
+        Box.new(@object_pool, x, y)
+        boxes += 1
+      end
+    end
+  end
+
+  def generate_powerups
+    pups = 0
+    target_pups = rand(20..30)
+    while pups < target_pups do
+      x = rand(0..MAP_WIDTH * TILE_SIZE)
+      y = rand(0..MAP_HEIGHT * TILE_SIZE)
+      if tile_at(x, y) != @water &&
+          @object_pool.nearby_point(x, y, 150).empty?
+        random_powerup.new(@object_pool, x, y)
+        pups += 1
+      end
+    end
+  end
+
+  def random_powerup
+    [HealthPowerup,
+     RepairPowerup,
+     FireRatePowerup,
+     TankSpeedPowerup].sample
+  end
+
+  def choose_tile(val)
+    case val
+    when 0.0..0.3 # 30% chance
+      @water
+    when 0.3..0.5 # 20% chance, water edges
+      @sand
+    else # 50% chance
+      @grass
+    end
+  end
+
+  private
+
+  def find_spawn_point
+    while true
+      x = rand(0..MAP_WIDTH * TILE_SIZE)
+      y = rand(0..MAP_HEIGHT * TILE_SIZE)
+      if can_move_to?(x, y) &&
+          @object_pool.nearby_point(x, y, 150).empty?
+        return [x, y]
+      end
+    end
+  end
+
+end