prkwars 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be17ea11de9dc8c7b62aacb87747f7d3cfe8b43e
-  data.tar.gz: '09d38b095375ec612d6d2338960c0183b3234fa1'
+  metadata.gz: bb20d88899bc28082f190eb177409668b28f7780
+  data.tar.gz: bda6b83f8d69d6ecf8a128ed8b8340a276980121
 SHA512:
-  metadata.gz: e7e6de2138e93758bd5effbbf8d04f0445a648457c08a9d5032a1cf04c109a178c2faae78dd0bd3c03c8b6f3bf82b4a679488dd316857147cabc5445fd37b5a7
-  data.tar.gz: b022f3dd68b3a998f50bb7fb5b5c22af3d0e393e96a5e37a5d278d269de65f16ccf0ec3227d78f960335957873817e9d1cd2fc83fa26bba41260d752d6c92068
+  metadata.gz: 62706249a60991fa7c40ae8973dfee889655865cda7ef88c110d2c92e5273c9c2d9484f6685e5961553a72af89e70fa868299640becaad294e523fc1adbf7419
+  data.tar.gz: 13011d79b3c81472568f2912e4bc90e1793a636f521bc1b6fd2e7a61d0ce34f8f69c1e7bddad3ae9c62b1bd2c0a4097174acf94f3f65bac3ef7a3b021b5bdf86

data/lib/prkwars.rb

@@ -2,4 +2,4 @@ PRKWARS_ROOT = File.dirname(File.expand_path(__FILE__))
 
 require_relative './prkwars/modules'
 Dir[File.join(PRKWARS_ROOT, '/prkwars/*.rb')].each { |f| require f }
-Gosu::Image.autoload_dirs << File.join(File.expand_path('../../.', __FILE__))
+Gosu::Image.autoload_dirs << File.join(File.expand_path('../../', __FILE__))

data/lib/prkwars/bullet.rb

@@ -1,14 +1,20 @@
 require_relative './modules.rb'
 require 'chingu'
 
+##
 # Class representing a bullet shot by the player. Destroys itself
 # if is present out of bounds.
+#
 class Bullet < Chingu::GameObject
   trait :velocity
   trait :bounding_box
   trait :collision_detection
   include GamespacePersistence
 
+  ##
+  # Initializes the gamespace where the bullet is present in. Velocity is
+  # passed as a paremeter in the options hash
+
   def initialize(gamespace, options = {})
     super(options)
     @image = Image['media/bullet.png']
@@ -17,6 +23,11 @@ class Bullet < Chingu::GameObject
     cache_bounding_box
   end
 
+  ##
+  # Updating position is not necessary thanks to the velocity trait.
+  # In case the bullet is out of bounds, it gets destroyed and explosion
+  # particles are spawned.
+
   def update
     return if in_bounds(self, @gamespace)
 

data/lib/prkwars/bullet_turret.rb

@@ -1,6 +1,7 @@
 require_relative './modules'
 require 'chingu'
 
+##
 # A bullet shot by the Turret enemy unit. Destroys itself if out of bounds.
 class BulletTurret < Chingu::GameObject
   trait :velocity
@@ -8,12 +9,20 @@ class BulletTurret < Chingu::GameObject
   trait :collision_detection
   include GamespacePersistence
 
+  ##
+  # Initializes gamespace in which the bullet is present and assigns
+  # the turret. Velocity of the bullet is passed as an options parameter,
+  # used by the chingu library.
   def initialize(gamespace, options = {})
     super(options)
     @image = Image['media/bullet_turret.png']
     @gamespace = gamespace
   end
 
+  ##
+  # As velocity is set by chingu, the only thing update does is that it checks
+  # whether there's any reason for the bullets to exist - if not, they get
+  # destroyed.
   def update
     destroy! unless in_bounds(self, @gamespace)
   end

data/lib/prkwars/enemy.rb

@@ -1,15 +1,22 @@
 require 'chingu'
 
+##
 # A generic Enemy class inheriting from Chingu::Gameobject. Any enemy
 # unit inherits from this class. The class contains a method
 # which returns all the descendants - useful for checking all possible
 # collisions.
+#
 class Enemy < Chingu::GameObject
+  ##
+  # Each enemy has hitpoints, how many has to be specified by the enemy class!
   attr_accessor :hp
   trait :bounding_box
   trait :collision_detection
   trait :timer
 
+  ##
+  # Method returning all the descendants of the Enemy class. Used for
+  # collision checks in the main game loop.
   def self.descendants
     ObjectSpace.each_object(::Class).select { |klass| klass < self }
   end

data/lib/prkwars/explosionparticle.rb

@@ -1,14 +1,20 @@
 require_relative './modules'
 require 'chingu'
 
+##
 # Class used for holding behaviour of particles during explosions of various
 # entitites.
+#
 class ExplosionParticle < Chingu::GameObject
   trait :velocity
   trait :effect # fade
   trait :bounding_box
   include GamespacePersistence
 
+  ##
+  # Generates an explosion particle with a set fade_rate (chingu). X and Y
+  # velocity is picked randomly between (-7..7).
+
   def initialize(gamespace, options = {})
     super(options)
 
@@ -21,6 +27,11 @@ class ExplosionParticle < Chingu::GameObject
     @angle = Math.atan2(@velocity_x, @velocity_y) / Math::PI * 180 + 90
   end
 
+  ##
+  # In case a particle collides with the gamespace boundaries, velocity
+  # gets corrected (impact angle to the other side). A particle gets
+  # destroyed once it completely fades out.
+
   def update
     velocity_correct! unless bounding_box.collide_rect?(@gamespace.bounding_box)
     destroy! if color.alpha.zero?
@@ -28,7 +39,9 @@ class ExplosionParticle < Chingu::GameObject
 
   private
 
+  ##
   # Method correcting the velocity if hitting a wall.
+
   def velocity_correct!
     if hitting_side
       @velocity_x = -@velocity_x
@@ -37,6 +50,9 @@ class ExplosionParticle < Chingu::GameObject
     end
   end
 
+  ##
+  # Method determining whether a particle is hitting a wall - used to correct
+  # the velocity values.
   def hitting_side
     if bounding_box.left < @gamespace.bounding_box.left ||
        bounding_box.right > @gamespace.bounding_box.right

data/lib/prkwars/game.rb

@@ -2,15 +2,16 @@ require_relative './play'
 require 'chingu'
 include Gosu
 
-# Game class which is reponsible for the whole game logic - generation
-# of the game space, generation of enemies and checking collisions between
-# them, destroying objects or reducing their HP if necessary.
+##
+# Game class is simply an encapsulation of the chingu window - essentially, the
+# entry point of the game.
+#
 class Game < Chingu::Window
-  attr_reader :player, :gamespace
-
+  ##
+  # Initialization of Game only creates a window of a specified size and
+  # pushes the beginning game state - +Splash+, into the game state stack.
   def initialize
     super(1280, 720)
-    # push_game_state(Play)
     push_game_state(Splash)
   end
 end

data/lib/prkwars/gameover.rb

@@ -1,7 +1,14 @@
 require 'chingu'
 
+##
 # Class representing the game over state shown when the player loses the game.
+#
 class GameOver < Chingu::GameState
+  ##
+  # Initialization of the game over screen does nothing else but map inputs to
+  # the +play+ method (in case the player wishes to play again) and draws text
+  # on the screen.
+
   def initialize(score, options = {})
     super(options)
 
@@ -12,6 +19,9 @@ class GameOver < Chingu::GameState
                         x: 20, y: 60)
   end
 
+  ##
+  # Switches the game state. Calls +Play.new+ instead of just Play in order
+  # to call the initialize method instead of the setup method.
   def play
     switch_game_state(Play.new)
   end

data/lib/prkwars/gamespace.rb

@@ -1,14 +1,22 @@
 require 'chingu'
 
+##
 # Class representing the space where the game is being played. Class is
 # essentially an encapsulation for the big rectangle where the game can be
 # played. Also holds possible spawn points for enemy entities.
+#
 class GameSpace < Chingu::GameObject
   trait :collision_detection
   trait :bounding_box
 
+  ##
+  # Accessor to the player - used by various enemies to determine the position
+  # of the player.
   attr_accessor :player
-  attr_reader :spawn_points
+
+  ##
+  # Initialization method sets up the spawn points for enemies and
+  # sets up the background image.
 
   def initialize(options = {})
     super(options)
@@ -17,6 +25,10 @@ class GameSpace < Chingu::GameObject
     setup_spawn_points
   end
 
+  ##
+  # Returns a random spawn point from the list of spawn points defined
+  # by the +setup_spawn_points+ method.
+
   def enemy_spawn_point(player_x, player_y)
     sample_points = points_far_enough(player_x, player_y)
 
@@ -25,6 +37,9 @@ class GameSpace < Chingu::GameObject
 
   private
 
+  ##
+  # Sets up a list of possible spawn points to be used by enemies.
+
   def setup_spawn_points
     @spawn_points = [[60, 60], [1200, 60], [60, 640], [1200, 640], [800, 640],
                      [800, 60], [800, 640], [250, 400], [500, 600],
@@ -32,6 +47,10 @@ class GameSpace < Chingu::GameObject
                      [1100, 420]]
   end
 
+  ##
+  # Returns a list of points which are far enough from the player. Minimum
+  # distance is arbitrary and at the moment set to 130 game units.
+
   def points_far_enough(player_x, player_y)
     points = []
 

data/lib/prkwars/modules.rb

@@ -1,22 +1,36 @@
 require 'chingu'
 
+##
+# Module containing Z order of various game objects.
 module ZOrder
   GAMEOBJECT = 2
 end
 
+##
+# Module containing constants used throughout the game.
 module Constants
   PLAYER_VELOCITY = 6
   BULLET_VELOCITY = 12
 end
 
+##
 # Module used by classes as a mixin for collision checking with the gamespace
 # so that they do not get out of bounds.
+#
 module GamespacePersistence
+  ##
+  # A method determining whether a gamespace +fully+ contains a certain
+  # game object.
+
   def in_bounds(entity, gamespace)
     return true if gamespace.bounding_box.contain?(entity.bounding_box)
     false
   end
 
+  ##
+  # A method determining game object coordinations in case they are out of
+  # bounds.
+
   def correct_coords(entity, gamespace)
     if entity.bounding_box.top < gamespace.bounding_box.top # ceiling
       entity.y += gamespace.bounding_box.top - entity.bounding_box.top

data/lib/prkwars/play.rb

@@ -1,20 +1,26 @@
 require 'chingu'
 
-# Class holding the gamestate of the gameplay itself.
+##
+# A class representing the game state of playing the game itself.
+#
 class Play < Chingu::GameState
   trait :timer
 
-  attr_reader :player, :gamespace
-
   PLAYER_START_X = 800
   PLAYER_START_Y = 640
 
   include GamespacePersistence
 
+  ##
+  # Initialization method of Play maps input to the exit function,
+  # creates a +gamespace+ to play in and spawns the +player+.
+  # Together with that, sets up variables for enemy generation,
+  # score calculation and message displays.
+
   def initialize(options = {})
     super(options)
 
-    self.input = { esc: :exit, p: :pause }
+    self.input = { esc: :exit }
 
     @gamespace = GameSpace.create(x: 1280 / 2, y: 720 / 2)
     @player = Player.create(@gamespace,
@@ -27,9 +33,11 @@ class Play < Chingu::GameState
     setup_display_messages
   end
 
-  def pause
-    switch_game_state(Splash)
-  end
+  ##
+  # Update loop does three major things each frame:
+  # * Collides enemies with player's bullets and reduces their HP if possible.
+  # * Collides enemies with player's ship and removes the player's life if so.
+  # * Performs another step in the enemy unit generation.
 
   def update
     super
@@ -39,12 +47,11 @@ class Play < Chingu::GameState
     generate_random_enemy
   end
 
-  def draw
-    super
-  end
-
   private
 
+  ##
+  # Sets up instance variables for score calculation.
+
   def setup_score_calculation
     @score = 0
     @multiplier = 1
@@ -52,6 +59,11 @@ class Play < Chingu::GameState
     @next_multiplier = 2000
   end
 
+  ##
+  # Called whenever an enemy dies and the score gets updated.
+  # Updates the score as well as the message displayed. Also
+  # pops up a +PopupText+ in case that score multiplier goes higher.
+
   def update_score
     @score += 100 * @multiplier
     @score_this_life += 100 * @multiplier
@@ -65,6 +77,13 @@ class Play < Chingu::GameState
     @next_multiplier *= 2
   end
 
+  ##
+  # A method colliding all the enemies with all the player bullets
+  # on the screen. In case an enemy gets hit, +ExplosionParticle+s get
+  # spawned and the enemy takes damage. In case the enemy dies, they
+  # get destroyed and a +PopupText+ is displayed to show how much
+  # score the player got.
+
   def collide_enemies_bullets
     Enemy.descendants.each do |enemy|
       enemy.each_bounding_box_collision(Bullet) do |nmy, bullet|
@@ -84,6 +103,11 @@ class Play < Chingu::GameState
     end
   end
 
+  ##
+  # A method coliding all the enemies with the player's unit.
+  # In case such a collision happens, player unit dies and
+  # the +handle_player_death+ method is called.
+
   def collide_enemies_player
     Enemy.descendants.each do |enemy|
       @player.each_bounding_box_collision(enemy) do
@@ -97,6 +121,9 @@ class Play < Chingu::GameState
     end
   end
 
+  ##
+  # A method generating random enemies. Steps up the framecounter
+  # for each enemy type by one and calls their corresponding methods.
   def generate_random_enemy
     @framecounter_turret += 1
     generate_random_turret
@@ -105,6 +132,11 @@ class Play < Chingu::GameState
     generate_random_stalker
   end
 
+  ##
+  # Generates a +Turret+ in a random position if the framecounter got
+  # to the next generation point. If so, the framecounter gets reset
+  # to zero.
+
   def generate_random_turret
     return if @framecounter_turret != @nextgen_turret
 
@@ -119,6 +151,11 @@ class Play < Chingu::GameState
     @nextgen_turret = rand(80..150)
   end
 
+  ##
+  # Generates a +Stalker+ in a random position if the framecounter got
+  # to the next generation point. If so, the framecounter gets reset
+  # to zero.
+
   def generate_random_stalker
     return if @framecounter_stalker != @nextgen_stalker
 
@@ -130,10 +167,16 @@ class Play < Chingu::GameState
     @nextgen_stalker = rand(20..50)
   end
 
+  ##
+  # Method spawning a +Warp+ at a point provided by the parameters..
+
   def create_warp(x, y)
     Warp.create(zorder: ZOrder::GAMEOBJECT, x: x, y: y)
   end
 
+  ##
+  # Method generating a random position for an enemy unit to spawn in.
+
   def generate_random_position
     x, y = @gamespace.enemy_spawn_point(@player.x, @player.y)
 
@@ -143,10 +186,20 @@ class Play < Chingu::GameState
     [x, y]
   end
 
+  ##
+  # Method switching to the +GameOver+ state.
+
   def handle_game_over
     switch_game_state(GameOver.new(@score))
   end
 
+  ##
+  # Method handling the death of a player.
+  # Kills all the units, reduces player's lives by one and goes to
+  # +GameOver+ if player's lives were reduced to zero.
+  # If not, +ExplosionParticle+s get spawned, all enemy generation
+  # is reset and the player starts from a new point.
+
   def handle_player_death
     kill_everything
     @player.lives -= 1
@@ -168,6 +221,9 @@ class Play < Chingu::GameState
     @player.y = PLAYER_START_Y
   end
 
+  ##
+  # Method killing all game objects except for the player's unit.
+
   def kill_everything
     Enemy.descendants.each do |enemy|
       ObjectSpace.each_object(enemy, &:destroy!)
@@ -178,6 +234,11 @@ class Play < Chingu::GameState
     ObjectSpace.each_object(Bullet, &:destroy!)
   end
 
+  ##
+  # Method setting up framecounters for each generation,
+  # generates a random number for the next generation of
+  # enemy units.
+
   def setup_enemy_generation
     @framecounter_turret = 0
     @nextgen_turret = rand(150..300)
@@ -185,6 +246,10 @@ class Play < Chingu::GameState
     @nextgen_stalker = rand(110..180)
   end
 
+  ##
+  # Method setting up the messages displayed in the HUD
+  # to show the amount of player's lives and the player's score.
+
   def setup_display_messages
     @message_lives = Chingu::Text.create("Lives: #{@player.lives}",
                                          x: 1020, y: 5, size: 30)

data/lib/prkwars/player.rb

@@ -1,6 +1,7 @@
 require_relative './modules'
 require 'chingu'
 
+##
 # Class holding all the logic related to the player - input controller
 # and any manipulation of player's sprite.
 class Player < Chingu::GameObject
@@ -16,6 +17,9 @@ class Player < Chingu::GameObject
   STARTING_BOMBS = 3
   INVUL_FRAMES = 30
 
+  ##
+  # Initialization of player assigns gamespace to the player, their sprite
+  # and sets the input layout for the player.
   def initialize(gamespace, options = {})
     super(options)
 
@@ -31,42 +35,74 @@ class Player < Chingu::GameObject
     @bombs = STARTING_BOMBS
   end
 
+  ##
+  # A method changing the player's y position by the +PLAYER_VELOCITY+
+  # constant.
+
   def move_up
     @y -= Constants::PLAYER_VELOCITY
     @y_change = -Constants::PLAYER_VELOCITY
   end
 
+  ##
+  # A method changing the player's y position by the +PLAYER_VELOCITY+
+  # constant.
+
   def move_down
     @y += Constants::PLAYER_VELOCITY
     @y_change = Constants::PLAYER_VELOCITY
   end
 
+  ##
+  # A method changing the player's x position by the +PLAYER_VELOCITY+
+  # constant.
+
   def move_left
     @x -= Constants::PLAYER_VELOCITY
     @x_change = -Constants::PLAYER_VELOCITY
   end
 
+  ##
+  # A method changing the player's x position by the +PLAYER_VELOCITY+
+  # constant.
+
   def move_right
     @x += Constants::PLAYER_VELOCITY
     @x_change = Constants::PLAYER_VELOCITY
   end
 
+  ##
+  # Sets the shooting vector's x part to +-BULLET_VELOCITY+.
+
   def shoot_left
     @shoot_vec_x = -Constants::BULLET_VELOCITY
   end
 
+  ##
+  # Sets the shooting vector's x part to +BULLET_VELOCITY+.
+
   def shoot_right
     @shoot_vec_x = Constants::BULLET_VELOCITY
   end
 
+  ##
+  # Sets the shooting vector's y part to +-BULLET_VELOCITY+.
+
   def shoot_up
     @shoot_vec_y = -Constants::BULLET_VELOCITY
   end
 
+  ##
+  # Sets the shooting vector's y part to +BULLET_VELOCITY+.
   def shoot_down
     @shoot_vec_y = Constants::BULLET_VELOCITY
   end
 
+  ##
+  # Method updating the player each frame. Player's sprite gets rotated
+  # to correspond to his movement direction. In case they're out of bounds
+  # the player's coordinates are corrected and bullets are shot if possible.
+
   def update
     rotate_player
     correct_coords(self, @gamespace) unless in_bounds(self, @gamespace)
@@ -79,6 +115,10 @@ class Player < Chingu::GameObject
 
   private
 
+  ##
+  # Initializes variables used by the player class to determine shooting
+  # speed as well as rotations of their sprite.
+
   def init_vector_variables
     @x_change = 0 # Used for rotating the triangular sprite
     @y_change = 0
@@ -87,6 +127,9 @@ class Player < Chingu::GameObject
     @shoot_vec_y = 0
   end
 
+  ##
+  # Rotates the player sprite if there was a change in their movement direction.
+
   def rotate_player
     return unless @x_change != 0 || @y_change != 0
 
@@ -98,6 +141,11 @@ class Player < Chingu::GameObject
     @y_change = 0
   end
 
+  ##
+  # Method shooting bullets in the direction which was input by the player.
+  # These directions are repesented by the @shoot_vec_x and @shoot_vec_y
+  # instance variables.
+
   def shoot_bullet
     return unless @shoot_vec_x != 0 || @shoot_vec_y != 0
 

data/lib/prkwars/popuptext.rb

@@ -1,20 +1,24 @@
 require 'chingu'
 include Gosu
 
+##
 # Class used for messages that pop up on the screen whenever something
 # relevant happens - e.g. score goes up.
+#
 class PopupText < Chingu::GameObject
-  trait :effect # fade
-  trait :velocity # move up slowly
+  ##
+  # Initialization method for +PopupText+ requires x, y to determine
+  # where the message gets spawned on the screen.
 
   def initialize(message, x, y, options = {})
     super(options)
 
-    @velocity_x = 0
-    @velocity_y = -2
     @msg = Chingu::Text.create(message, x: x, y: y, size: 30)
   end
 
+  ##
+  # Updating the popuptext changes the y coordinate and slowly fades
+  # the message out.
   def update
     @msg.y -= 1
     @msg.color.alpha -= 4

data/lib/prkwars/splash.rb

@@ -1,7 +1,13 @@
 require 'chingu'
 
+##
 # Class representing the game state right after turning the game on.
+
 class Splash < Chingu::GameState
+  ##
+  # A setup method called by the chingu library when the +Splash+ class
+  # gets pushed into the game state stack/gets switched to.
+  # Sets up input for exit/playing the game and sets up splash messages.
   def setup
     self.input = { space: :play, esc: :exit }
     Chingu::Text.create('PRK WARS',
@@ -15,6 +21,10 @@ class Splash < Chingu::GameState
                         x: 20, y: 170, size: 30)
   end
 
+  ##
+  # A method called when the player presses space in order to play the game.
+  # Uses the +transitional_game_state+ method provided by the +chingu+ library
+  # in order to make things prettier.
   def play
     transitional_game_state(Chingu::GameStates::FadeTo, speed: 10)
     switch_game_state(Play.new)

data/lib/prkwars/stalker.rb

@@ -1,14 +1,20 @@
 require_relative './enemy'
 require 'chingu'
 
+##
 # Class representing the Stalker enemy unit which is mobile but unable to
 # shoot and endlessly moves towards the player unit.
+#
 class Stalker < Enemy
   trait :velocity
   include GamespacePersistence
   VELOCITY = 2
   HP = 1
 
+  ##
+  # Initialization of the Stalker unit requires the gamespace for collision
+  # checks, sets the sprite and HP of the unit to an instance variable.
+
   def initialize(gamespace, options = {})
     super(options)
 
@@ -18,6 +24,10 @@ class Stalker < Enemy
     @hp = HP
   end
 
+  ##
+  # Every time a Stalker unit gets updated, they move in a constant speed
+  # towards the player. Their sprite also gets rotated.
+
   def update
     dist_x = @gamespace.player.x - @x
     dist_y = @gamespace.player.y - @y
@@ -33,6 +43,8 @@ class Stalker < Enemy
     @angle = rot_to
   end
 
+  ##
+  # A common method to enemies, reducing their HP by one.
   def take_damage
     @hp -= 1
   end

data/lib/prkwars/turret.rb

@@ -3,13 +3,21 @@ require_relative './enemy'
 require_relative './bullet_turret'
 require 'chingu'
 
+##
 # Class representing the Turret enemy unit which is stationary and endlessly
 # shoots bullets in the direction of the player.
+#
 class Turret < Enemy
   SHOOT_GAP = 40
   VELOCITY = 3
   HP = 3
 
+  ##
+  # Initializing a +Turret+ builds a new +Chingu::Animation+ with the
+  # turret sprites. Each time a +Turret+ gets hit, it changes its sprite
+  # to better display the amount of HP. Also sets the gamespace instance variable,
+  # HP and a shooting timer.
+
   def initialize(gamespace, options = {})
     super(options)
 
@@ -21,6 +29,10 @@ class Turret < Enemy
     @image = @animation[@hp - 1]
   end
 
+  ##
+  # Updating a +Turret+ only consists of shooting a bullet if the framecounter
+  # got far enough.
+
   def update
     @shoot_timer += 1
     return unless @shoot_timer == SHOOT_GAP
@@ -29,6 +41,9 @@ class Turret < Enemy
     @shoot_timer = 0
   end
 
+  ##
+  # A common +Enemy+ method - reduces the unit's HP by one and changes the
+  # sprite.
   def take_damage
     @hp -= 1
     @image = @animation[@hp - 1]
@@ -36,6 +51,8 @@ class Turret < Enemy
 
   private
 
+  ##
+  # Shoots a bullet at a proper velocity towards the player's unit.
   def shoot_bullet
     dist_x = @gamespace.player.x - @x
     dist_y = @gamespace.player.y - @y

data/lib/prkwars/warp.rb

@@ -5,6 +5,8 @@ require 'chingu'
 class Warp < Chingu::GameObject
   trait :effect # fade
 
+  ##
+  # Sets the image of a warp as well as its fade rate.
   def initialize(options = {})
     super(options)
 
@@ -12,6 +14,8 @@ class Warp < Chingu::GameObject
     @image = Image['media/warp.png']
   end
 
+  ##
+  # Destroys a +Warp+ if it faded out.
   def update
     destroy! if color.alpha.zero?
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prkwars
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Marek Pikna