tank_island 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d532027c65a76a3a675c7bddbd7ed6699bf74880
+  data.tar.gz: 90459a44a1e0e4f91796ac0188e54f75ac64277a
+SHA512:
+  metadata.gz: bd1d1bd1afed378b9655e77d6b7ee5972d7c37aa0e904cecdbee7f2c35b93075c145b4ef37ef5241026f994da48e98149df7f925c9538fed83eb336c4df1d657
+  data.tar.gz: b85eed9ea5b0fd7e7c9ba709b502a3e1a489c92399bd0f5daea7f2c47202f5be8b09f71a537edc8bf8ee3b6d6f630390836cde81a5ac54df31869f631fe8811b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-version

@@ -0,0 +1 @@
+2.1.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tank_island.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tomas Varaneckas
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Tank Island
+
+Tank Island is an open source 2D top down shooter game that was created with Ruby using
+[Gosu](http://www.libgosu.org) game development library while writing
+[this book](https://leanpub.com/developing-games-with-ruby/read).
+
+## Screenshots
+
+![Tank Island Game](https://dl.dropboxusercontent.com/u/176100/tank_island/screen1.png)
+
+![Tank Island Game](https://dl.dropboxusercontent.com/u/176100/tank_island/screen2.png)
+
+[Gameplay video on YouTube](https://www.youtube.com/watch?v=PpbnCUBrXXU)
+
+## Book: Developing Games With Ruby
+
+Complete process of building this game is described step by step in this free to read book:
+
+[Developing Games With Ruby](https://leanpub.com/developing-games-with-ruby/read)
+
+## Installation
+
+To install it, run
+
+    $ gem install tank_island
+
+On Mac OSX you will have to `brew install imagemagick` to make it work.
+
+## Starting the game
+
+There are several ways to start the game.
+
+### Running in 800x600 window mode
+
+    $ tank_island
+
+### Running with custom resolution
+
+    $ w=1600 h=1200 tank_island
+
+### Running full screen with custom resolution
+
+    $ fs=1 w=1200 h=800 tank_island
+
+## Controls
+
+### Gameplay
+
+- `W` `A` `S` `D` moves your tank.
+- Mouse `left click` shoots.
+- `ESC` goes into menu and away from it.
+
+### Debugging
+
+- `R` respawns your tank.
+- `T` spawns an enemy tank under mouse cursor.
+- `F1` enters debug mode.
+- `F2` toggles profiling

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/tank_island

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'gosu'
+require 'gosu_texture_packer'
+require 'perlin_noise'
+
+root_dir = File.expand_path(File.join(
+  File.dirname(File.dirname(__FILE__)), 'lib'))
+require_pattern = File.join(root_dir, '**/*.rb')
+@failed = []
+
+# Dynamically require everything
+Dir.glob(require_pattern).each do |f|
+  begin
+    require f
+  rescue
+    # May fail if parent class not required yet
+    @failed << f
+  end
+end
+
+# Retry unresolved requires
+@failed.each do |f|
+  require f.gsub("#{root_dir}/", '')
+end
+
+$debug = false
+$window = GameWindow.new
+GameState.switch(MenuState.instance)
+$window.show

data/lib/entities/box.rb

@@ -0,0 +1,28 @@
+class Box < GameObject
+  attr_reader :health, :graphics, :angle
+
+  def initialize(object_pool, x, y)
+    super
+    @graphics = BoxGraphics.new(self)
+    @health = Health.new(self, object_pool, 10, true)
+    @angle = rand(-15..15)
+  end
+
+  def on_collision(object)
+    return unless object.physics.speed > 1.0
+    move(*Utils.point_at_distance(@x, @y, object.direction, 2))
+    @box = nil
+  end
+
+  def box
+    return @box if @box
+    w = @graphics.width / 2
+    h = @graphics.height / 2
+    # Bounding box adjusted to trim shadows
+    @box = [x - w + 4,     y - h + 8,
+            x + w , y - h + 8,
+            x + w , y + h,
+            x - w + 4,     y + h]
+    @box = Utils.rotate(@angle, @x, @y, *@box)
+  end
+end

data/lib/entities/bullet.rb

@@ -0,0 +1,26 @@
+class Bullet < GameObject
+  attr_accessor :target_x, :target_y, :source, :speed, :fired_at
+
+  def initialize(object_pool, source_x, source_y, target_x, target_y)
+    super(object_pool, source_x, source_y)
+    @target_x, @target_y = target_x, target_y
+    BulletPhysics.new(self, object_pool)
+    BulletGraphics.new(self)
+    BulletSounds.play(self, object_pool.camera)
+  end
+
+  def box
+    [@x, @y]
+  end
+
+  def explode
+    Explosion.new(object_pool, @x, @y, @source)
+    mark_for_removal
+  end
+
+  def fire(source, speed)
+    @source = source
+    @speed = speed
+    @fired_at = Gosu.milliseconds
+  end
+end

data/lib/entities/camera.rb

@@ -0,0 +1,113 @@
+class Camera
+  attr_accessor :x, :y, :zoom
+  attr_reader :target
+
+  def target=(target)
+    @target = target
+    @x, @y = target.x, target.y
+    @zoom = 1
+  end
+
+  def desired_spot
+    if @target.physics.moving?
+      Utils.point_at_distance(
+        @target.x, @target.y,
+        @target.direction,
+        @target.physics.speed.ceil * 25)
+    else
+      [@target.x, @target.y]
+    end
+  end
+
+  def mouse_coords
+    x, y = target_delta_on_screen
+    mouse_x_on_map = @target.x +
+      (x + $window.mouse_x - ($window.width / 2)) / @zoom
+    mouse_y_on_map = @target.y +
+      (y + $window.mouse_y - ($window.height / 2)) / @zoom
+    [mouse_x_on_map, mouse_y_on_map].map(&:round)
+  end
+
+  def update
+    des_x, des_y = desired_spot
+    shift = Utils.adjust_speed(
+      @target.physics.speed).floor *
+      @target.speed_modifier + 1
+    if @x < des_x
+      if des_x - @x < shift
+        @x = des_x
+      else
+        @x += shift
+      end
+    elsif @x > des_x
+      if @x - des_x < shift
+        @x = des_x
+      else
+        @x -= shift
+      end
+    end
+    if @y < des_y
+      if des_y - @y < shift
+        @y = des_y
+      else
+        @y += shift
+      end
+    elsif @y > des_y
+      if @y - des_y < shift
+        @y = des_y
+      else
+        @y -= shift
+      end
+    end
+
+    zoom_delta = @zoom > 0 ? 0.01 : 1.0
+    zoom_delta = Utils.adjust_speed(zoom_delta)
+    if $window.button_down?(Gosu::KbUp)
+      @zoom -= zoom_delta unless @zoom < 0.7
+    elsif $window.button_down?(Gosu::KbDown)
+      @zoom += zoom_delta unless @zoom > 10
+    else
+      target_zoom = @target.physics.speed > 1.1 ? 0.75 : 1.0
+      if @zoom <= (target_zoom - 0.01)
+        @zoom += zoom_delta / 3
+      elsif @zoom > (target_zoom + 0.01)
+        @zoom -= zoom_delta / 3
+      end
+    end
+  end
+
+  def to_s
+    "FPS: #{Gosu.fps}. " <<
+      "#{@x}:#{@y} @ #{'%.2f' % @zoom}. " <<
+      'WASD to move, arrows to zoom.'
+  end
+
+  def target_delta_on_screen
+    [(@x - @target.x) * @zoom, (@y - @target.y) * @zoom]
+  end
+
+  def draw_crosshair
+    factor = 0.5
+    x = $window.mouse_x
+    y = $window.mouse_y
+    c = crosshair
+    c.draw(x - c.width * factor / 2,
+           y - c.height * factor / 2,
+           1000, factor, factor)
+  end
+
+  def viewport
+    x0 = @x - ($window.width / 2)  / @zoom
+    x1 = @x + ($window.width / 2)  / @zoom
+    y0 = @y - ($window.height / 2) / @zoom
+    y1 = @y + ($window.height / 2) / @zoom
+    [x0, x1, y0, y1]
+  end
+
+  private
+
+  def crosshair
+    @crosshair ||= Gosu::Image.new(
+      $window, Utils.media_path('c_dot.png'), false)
+  end
+end

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

@@ -0,0 +1,114 @@
+class AiGun
+  DECISION_DELAY = 300
+  attr_reader :target, :desired_gun_angle
+
+  def initialize(object, vision)
+    @object = object
+    @vision = vision
+    @desired_gun_angle = rand(0..360)
+    @retarget_speed = rand(1..5)
+    @accuracy = rand(0..10)
+    @aggressiveness = rand(1..5)
+  end
+
+  def adjust_angle
+    adjust_desired_angle
+    adjust_gun_angle
+  end
+
+  def update
+    if @vision.in_sight.any?
+      if @vision.closest_tank != @target
+        change_target(@vision.closest_tank)
+      end
+    else
+      @target = nil
+    end
+
+    if @target
+      if (0..30 - rand(0..@accuracy)).include?(
+        (@desired_gun_angle - @object.gun_angle).abs.round)
+        distance = distance_to_target
+        if distance - 50 <= BulletPhysics::MAX_DIST
+          target_x, target_y = Utils.point_at_distance(
+            @object.x, @object.y, @object.gun_angle,
+            distance + 10 - rand(0..@accuracy))
+          if can_make_new_decision? && @object.can_shoot? &&
+              should_shoot?
+            @object.shoot(target_x, target_y)
+          end
+        end
+      end
+    end
+  end
+
+  def draw(viewport)
+    if $debug
+      color = Gosu::Color::BLUE
+      x, y = @object.x, @object.y
+      t_x, t_y = Utils.point_at_distance(x, y, @desired_gun_angle,
+                                         BulletPhysics::MAX_DIST)
+      $window.draw_line(x, y, color, t_x, t_y, color, 1001)
+      color = Gosu::Color::RED
+      t_x, t_y = Utils.point_at_distance(x, y, @object.gun_angle,
+                                         BulletPhysics::MAX_DIST)
+      $window.draw_line(x, y, color, t_x, t_y, color, 1000)
+    end
+  end
+
+  def distance_to_target
+    Utils.distance_between(
+      @object.x, @object.y, @target.x, @target.y)
+  end
+
+
+  def should_shoot?
+    rand * @aggressiveness > 0.3
+  end
+
+  def can_make_new_decision?
+    now = Gosu.milliseconds
+    if now - (@last_decision ||= 0) > DECISION_DELAY
+      @last_decision = now
+      true
+    end
+  end
+
+  def adjust_desired_angle
+    @desired_gun_angle = if @target
+       Utils.angle_between(
+        @object.x, @object.y, @target.x, @target.y)
+    else
+      @object.direction
+    end
+  end
+
+  def change_target(new_target)
+    @target = new_target
+    adjust_desired_angle
+  end
+
+  def adjust_gun_angle
+    actual = @object.gun_angle
+    desired = @desired_gun_angle
+    if actual > desired
+      if actual - desired > 180 # 0 -> 360 fix
+        @object.gun_angle = (actual + @retarget_speed) % 360
+        if @object.gun_angle < desired
+          @object.gun_angle = desired # damp
+        end
+      else
+        @object.gun_angle = [actual - @retarget_speed, desired].max
+      end
+    elsif actual < desired
+      if desired - actual > 180 # 360 -> 0 fix
+        @object.gun_angle = (360 + actual - @retarget_speed) % 360
+        if @object.gun_angle > desired
+          @object.gun_angle = desired # damp
+        end
+      else
+        @object.gun_angle = [actual + @retarget_speed, desired].min
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+class TankChasingState < TankMotionState
+  def initialize(object, vision, gun)
+    super(object, vision)
+    @object = object
+    @vision = vision
+    @gun = gun
+  end
+
+  def update
+    change_direction if should_change_direction?
+    drive
+  end
+
+  def change_direction
+    @object.physics.change_direction(
+      @gun.desired_gun_angle -
+      @gun.desired_gun_angle % 45)
+
+    @changed_direction_at = Gosu.milliseconds
+    @will_keep_direction_for = turn_time
+  end
+
+  def drive_time
+    10000
+  end
+
+  def turn_time
+    rand(300..600)
+  end
+end