prkwars 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f148993f8f36cbef84d775439462a7ac06cc4c1
+  data.tar.gz: bd0bffc487588e44e113f51bd91536a257dd0af2
+SHA512:
+  metadata.gz: 8861ae042979ea10ef8bb8b6f5471ac7e55c328416e81091600566043095364b44bfa1f27ef1da6925c33ed47b8369e143d7267702e318866b03506ca5eedb76
+  data.tar.gz: 221db7ba52d96a1a4e4e11c8d035069fcca794b5fbc56fb078d8d727d35d36038dbf100f38c091e5657a089fd44e2a168671fdf0b3f153cb144b7679d50cdd9b

data/bin/prkwars

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'prkwars'
+
+Game.new.show

data/lib/prkwars/bullet.rb

@@ -0,0 +1,30 @@
+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
+
+  def initialize(gamespace, options = {})
+    super(options)
+    @image = Image['media/bullet.png']
+    @gamespace = gamespace
+
+    cache_bounding_box
+  end
+
+  def update
+    return if in_bounds(self, @gamespace)
+
+    2.times do
+      ExplosionParticle.create(@gamespace,
+                               x: @x, y: @y,
+                               zorder: ZOrder::GAMEOBJECT)
+      destroy!
+    end
+  end
+end

data/lib/prkwars/bullet_turret.rb

@@ -0,0 +1,20 @@
+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
+  trait :bounding_box
+  trait :collision_detection
+  include GamespacePersistence
+
+  def initialize(gamespace, options = {})
+    super(options)
+    @image = Image['media/bullet_turret.png']
+    @gamespace = gamespace
+  end
+
+  def update
+    destroy! unless in_bounds(self, @gamespace)
+  end
+end

data/lib/prkwars/enemy.rb

@@ -0,0 +1,16 @@
+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
+  attr_accessor :hp
+  trait :bounding_box
+  trait :collision_detection
+  trait :timer
+
+  def self.descendants
+    ObjectSpace.each_object(::Class).select { |klass| klass < self }
+  end
+end

data/lib/prkwars/explosionparticle.rb

@@ -0,0 +1,48 @@
+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
+
+  def initialize(gamespace, options = {})
+    super(options)
+
+    @gamespace = gamespace
+    @fade_rate = -3
+    @mode = :default
+    @image = Image['media/myparticle.png']
+    @velocity_x = rand(-7..7)
+    @velocity_y = rand(-7..7)
+    @angle = Math.atan2(@velocity_x, @velocity_y) / Math::PI * 180 + 90
+  end
+
+  def update
+    velocity_correct! unless bounding_box.collide_rect?(@gamespace.bounding_box)
+    destroy! if color.alpha.zero?
+  end
+
+  private
+
+  # Method correcting the velocity if hitting a wall.
+  def velocity_correct!
+    if hitting_side
+      @velocity_x = -@velocity_x
+    else
+      @velocity_y = -@velocity_y
+    end
+  end
+
+  def hitting_side
+    if bounding_box.left < @gamespace.bounding_box.left ||
+       bounding_box.right > @gamespace.bounding_box.right
+      true
+    else
+      false
+    end
+  end
+end

data/lib/prkwars/game.rb

@@ -0,0 +1,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.
+class Game < Chingu::Window
+  attr_reader :player, :gamespace
+
+  def initialize
+    super(1280, 720)
+    # push_game_state(Play)
+    push_game_state(Splash)
+  end
+end

data/lib/prkwars/gameover.rb

@@ -0,0 +1,18 @@
+require 'chingu'
+
+# Class representing the game over state shown when the player loses the game.
+class GameOver < Chingu::GameState
+  def initialize(score, options = {})
+    super(options)
+
+    self.input = { space: :play, esc: :exit }
+
+    Chingu::Text.create("Final score: #{score}", x: 20, y: 20, size: 30)
+    Chingu::Text.create('Press <space> to play again, <esc> to exit.',
+                        x: 20, y: 60)
+  end
+
+  def play
+    switch_game_state(Play.new)
+  end
+end

data/lib/prkwars/gamespace.rb

@@ -0,0 +1,47 @@
+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
+
+  attr_accessor :player
+  attr_reader :spawn_points
+
+  def initialize(options = {})
+    super(options)
+
+    @image = Image['media/background.png']
+    setup_spawn_points
+  end
+
+  def enemy_spawn_point(player_x, player_y)
+    sample_points = points_far_enough(player_x, player_y)
+
+    sample_points.sample
+  end
+
+  private
+
+  def setup_spawn_points
+    @spawn_points = [[60, 60], [1200, 60], [60, 640], [1200, 640], [800, 640],
+                     [800, 60], [800, 640], [250, 400], [500, 600],
+                     [120, 640], [340, 520], [380, 640], [960, 80],
+                     [1100, 420]]
+  end
+
+  def points_far_enough(player_x, player_y)
+    points = []
+
+    @spawn_points.each do |point|
+      dist = Math.sqrt((player_x - point[0]) * (player_x - point[0]) +
+                       (player_y - point[1]) * (player_y - point[1]))
+
+      points.push(point) if dist > 130
+    end
+
+    points
+  end
+end

data/lib/prkwars/modules.rb

@@ -0,0 +1,32 @@
+require 'chingu'
+
+module ZOrder
+  GAMEOBJECT = 2
+end
+
+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
+  def in_bounds(entity, gamespace)
+    return true if gamespace.bounding_box.contain?(entity.bounding_box)
+    false
+  end
+
+  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
+    elsif entity.bounding_box.bottom > gamespace.bounding_box.bottom # floor
+      entity.y -= entity.bounding_box.bottom - gamespace.bounding_box.bottom
+    end
+    if entity.bounding_box.left < gamespace.bounding_box.left # left side
+      entity.x += gamespace.bounding_box.left - entity.bounding_box.left
+    elsif entity.bounding_box.right > gamespace.bounding_box.right # right side
+      entity.x -= entity.bounding_box.right - gamespace.bounding_box.right
+    end
+  end
+end

data/lib/prkwars/play.rb

@@ -0,0 +1,195 @@
+require 'chingu'
+
+# Class holding the gamestate of the gameplay itself.
+class Play < Chingu::GameState
+  trait :timer
+
+  attr_reader :player, :gamespace
+
+  PLAYER_START_X = 800
+  PLAYER_START_Y = 640
+
+  include GamespacePersistence
+
+  def initialize(options = {})
+    super(options)
+
+    self.input = { esc: :exit, p: :pause }
+
+    @gamespace = GameSpace.create(x: 1280 / 2, y: 720 / 2)
+    @player = Player.create(@gamespace,
+                            zorder: ZOrder::GAMEOBJECT,
+                            x: PLAYER_START_X, y: PLAYER_START_Y)
+    @gamespace.player = @player
+
+    setup_enemy_generation
+    setup_score_calculation
+    setup_display_messages
+  end
+
+  def pause
+    switch_game_state(Splash)
+  end
+
+  def update
+    super
+    collide_enemies_bullets
+    collide_enemies_player
+
+    generate_random_enemy
+  end
+
+  def draw
+    super
+  end
+
+  private
+
+  def setup_score_calculation
+    @score = 0
+    @multiplier = 1
+    @score_this_life = 0
+    @next_multiplier = 2000
+  end
+
+  def update_score
+    @score += 100 * @multiplier
+    @score_this_life += 100 * @multiplier
+
+    @message_score.text = "Score: #{@score}"
+
+    return if @score_this_life != @next_multiplier
+
+    @multiplier += 1
+    PopupText.create("#{@multiplier}x Multiplier", @player.x, @player.y - 10)
+    @next_multiplier *= 2
+  end
+
+  def collide_enemies_bullets
+    Enemy.descendants.each do |enemy|
+      enemy.each_bounding_box_collision(Bullet) do |nmy, bullet|
+        10.times do
+          ExplosionParticle.create(@gamespace,
+                                   x: bullet.x, y: bullet.y,
+                                   zorder: ZOrder::GAMEOBJECT)
+        end
+        bullet.destroy!
+        nmy.take_damage
+        next unless nmy.hp.zero?
+        Warp.create(zorder: ZOrder::GAMEOBJECT, x: nmy.x, y: nmy.y)
+        PopupText.create((100 * @multiplier).to_s, nmy.x, nmy.y)
+        nmy.destroy
+        update_score
+      end
+    end
+  end
+
+  def collide_enemies_player
+    Enemy.descendants.each do |enemy|
+      @player.each_bounding_box_collision(enemy) do
+        handle_player_death
+        return true # no need to check collisions of turret bullets
+      end
+    end
+
+    @player.each_bounding_box_collision(BulletTurret) do
+      handle_player_death
+    end
+  end
+
+  def generate_random_enemy
+    @framecounter_turret += 1
+    generate_random_turret
+
+    @framecounter_stalker += 1
+    generate_random_stalker
+  end
+
+  def generate_random_turret
+    return if @framecounter_turret != @nextgen_turret
+
+    x, y = generate_random_position
+    turret = Turret.create(@gamespace, zorder: ZOrder::GAMEOBJECT, x: x, y: y)
+
+    correct_coords(turret, @gamespace)
+
+    create_warp(x, y)
+
+    @framecounter_turret = 0
+    @nextgen_turret = rand(80..150)
+  end
+
+  def generate_random_stalker
+    return if @framecounter_stalker != @nextgen_stalker
+
+    x, y = generate_random_position
+    Stalker.create(@gamespace, zorder: ZOrder::GAMEOBJECT, x: x, y: y)
+    create_warp(x, y)
+
+    @framecounter_stalker = 0
+    @nextgen_stalker = rand(20..50)
+  end
+
+  def create_warp(x, y)
+    Warp.create(zorder: ZOrder::GAMEOBJECT, x: x, y: y)
+  end
+
+  def generate_random_position
+    x, y = @gamespace.enemy_spawn_point(@player.x, @player.y)
+
+    x += rand(-30..30)
+    y += rand(-30..30)
+
+    [x, y]
+  end
+
+  def handle_game_over
+    switch_game_state(GameOver.new(@score))
+  end
+
+  def handle_player_death
+    kill_everything
+    @player.lives -= 1
+    handle_game_over if @player.lives.zero?
+
+    500.times do
+      ExplosionParticle.create(@gamespace,
+                               x: @player.x, y: @player.y,
+                               zorder: ZOrder::GAMEOBJECT)
+    end
+
+    setup_enemy_generation
+    @message_lives.text = "Lives: #{@player.lives}"
+    @score_this_life = 0
+    @next_multiplier = 2000
+    @multiplier = 1
+    PopupText.create("#{@multiplier}x Multiplier", @player.x, @player.y - 10)
+    @player.x = PLAYER_START_X
+    @player.y = PLAYER_START_Y
+  end
+
+  def kill_everything
+    Enemy.descendants.each do |enemy|
+      ObjectSpace.each_object(enemy, &:destroy!)
+    end
+
+    ObjectSpace.each_object(BulletTurret, &:destroy!)
+
+    ObjectSpace.each_object(Bullet, &:destroy!)
+  end
+
+  def setup_enemy_generation
+    @framecounter_turret = 0
+    @nextgen_turret = rand(150..300)
+    @framecounter_stalker = 0
+    @nextgen_stalker = rand(110..180)
+  end
+
+  def setup_display_messages
+    @message_lives = Chingu::Text.create("Lives: #{@player.lives}",
+                                         x: 1020, y: 5, size: 30)
+
+    @message_score = Chingu::Text.create("Score: #{@score}",
+                                         x: 100, y: 5, size: 30)
+  end
+end

data/lib/prkwars/player.rb

@@ -0,0 +1,128 @@
+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
+  trait :bounding_box
+  trait :collision_detection
+
+  attr_accessor :lives
+  attr_reader :invulnerable
+
+  include GamespacePersistence
+  STARTING_LIVES = 3
+  SHOOT_GAP = 8
+  STARTING_BOMBS = 3
+  INVUL_FRAMES = 30
+
+  def initialize(gamespace, options = {})
+    super(options)
+
+    @image = Image['./media/player_ship.png']
+    self.input = { holding_w: :move_up, holding_a: :move_left,
+                   holding_d: :move_right, holding_s: :move_down,
+                   holding_left: :shoot_left, holding_right: :shoot_right,
+                   holding_up: :shoot_up, holding_down: :shoot_down }
+    init_vector_variables
+
+    @gamespace = gamespace
+    @lives = STARTING_LIVES
+    @bombs = STARTING_BOMBS
+  end
+
+  def move_up
+    @y -= Constants::PLAYER_VELOCITY
+    @y_change = -Constants::PLAYER_VELOCITY
+  end
+
+  def move_down
+    @y += Constants::PLAYER_VELOCITY
+    @y_change = Constants::PLAYER_VELOCITY
+  end
+
+  def move_left
+    @x -= Constants::PLAYER_VELOCITY
+    @x_change = -Constants::PLAYER_VELOCITY
+  end
+
+  def move_right
+    @x += Constants::PLAYER_VELOCITY
+    @x_change = Constants::PLAYER_VELOCITY
+  end
+
+  def shoot_left
+    @shoot_vec_x = -Constants::BULLET_VELOCITY
+  end
+
+  def shoot_right
+    @shoot_vec_x = Constants::BULLET_VELOCITY
+  end
+
+  def shoot_up
+    @shoot_vec_y = -Constants::BULLET_VELOCITY
+  end
+
+  def shoot_down
+    @shoot_vec_y = Constants::BULLET_VELOCITY
+  end
+
+  def update
+    rotate_player
+    correct_coords(self, @gamespace) unless in_bounds(self, @gamespace)
+    @shoot_timer += 1
+    return unless @shoot_timer == SHOOT_GAP
+
+    shoot_bullet
+    @shoot_timer = 0
+  end
+
+  private
+
+  def init_vector_variables
+    @x_change = 0 # Used for rotating the triangular sprite
+    @y_change = 0
+    @shoot_timer = 0
+    @shoot_vec_x = 0 # Used for deciding the shooting direction
+    @shoot_vec_y = 0
+  end
+
+  def rotate_player
+    return unless @x_change != 0 || @y_change != 0
+
+    rot_to = Math.atan2(@y_change, @x_change) / Math::PI * 180 + 90
+
+    self.angle = rot_to
+
+    @x_change = 0
+    @y_change = 0
+  end
+
+  def shoot_bullet
+    return unless @shoot_vec_x != 0 || @shoot_vec_y != 0
+
+    bullet_angle = Math.atan2(@shoot_vec_y, @shoot_vec_x) / Math::PI * 180 - 180
+
+    norm_x = -@shoot_vec_y
+    norm_y = @shoot_vec_x
+
+    dist_norm = Math.sqrt(norm_x * norm_x + norm_y * norm_y)
+
+    unit_x = norm_x / dist_norm
+    unit_y = norm_y / dist_norm
+
+    Bullet.create(@gamespace,
+                  zorder: ZOrder::GAMEOBJECT, x: @x + unit_x * 7,
+                  y: @y + unit_y * 7,
+                  velocity_x: @shoot_vec_x, velocity_y: @shoot_vec_y,
+                  angle: bullet_angle)
+
+    Bullet.create(@gamespace,
+                  zorder: ZOrder::GAMEOBJECT, x: @x - unit_x * 7,
+                  y: @y - unit_y * 7,
+                  velocity_x: @shoot_vec_x, velocity_y: @shoot_vec_y,
+                  angle: bullet_angle)
+    @shoot_vec_x = 0
+    @shoot_vec_y = 0
+  end
+end

data/lib/prkwars/popuptext.rb

@@ -0,0 +1,23 @@
+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
+
+  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
+
+  def update
+    @msg.y -= 1
+    @msg.color.alpha -= 4
+    @msg.destroy! if color.alpha.zero?
+  end
+end

data/lib/prkwars/splash.rb

@@ -0,0 +1,22 @@
+require 'chingu'
+
+# Class representing the game state right after turning the game on.
+class Splash < Chingu::GameState
+  def setup
+    self.input = { space: :play, esc: :exit }
+    Chingu::Text.create('PRK WARS',
+                        x: 20, y: 20, size: 60, color: Gosu::Color::RED)
+    Chingu::Text.create('A simple Grid Wars/Geometry Wars clone',
+                        x: 20, y: 90, size: 30)
+    Chingu::Text.create('Press <space> to play the game, <esc> to exit.',
+                        x: 20, y: 130, size: 30)
+    Chingu::Text.create('Controls: WASD: movement, arrow keys: shooting'\
+                        ' direction.',
+                        x: 20, y: 170, size: 30)
+  end
+
+  def play
+    transitional_game_state(Chingu::GameStates::FadeTo, speed: 10)
+    switch_game_state(Play.new)
+  end
+end

data/lib/prkwars/stalker.rb

@@ -0,0 +1,39 @@
+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
+
+  def initialize(gamespace, options = {})
+    super(options)
+
+    @image = Image['./media/stalker.png']
+
+    @gamespace = gamespace
+    @hp = HP
+  end
+
+  def update
+    dist_x = @gamespace.player.x - @x
+    dist_y = @gamespace.player.y - @y
+
+    rot_to = Math.atan2(dist_y, dist_x) / Math::PI * 180 + 90
+
+    dist = Math.sqrt(dist_x * dist_x + dist_y * dist_y)
+
+    ticks = dist / VELOCITY
+
+    @velocity_x = dist_x / ticks
+    @velocity_y = dist_y / ticks
+    @angle = rot_to
+  end
+
+  def take_damage
+    @hp -= 1
+  end
+end

data/lib/prkwars/turret.rb

@@ -0,0 +1,54 @@
+require_relative './modules'
+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
+
+  def initialize(gamespace, options = {})
+    super(options)
+
+    @animation = Chingu::Animation.new(file: 'media/turrets.png', size: 32)
+
+    @gamespace = gamespace
+    @hp = HP
+    @shoot_timer = 0
+    @image = @animation[@hp - 1]
+  end
+
+  def update
+    @shoot_timer += 1
+    return unless @shoot_timer == SHOOT_GAP
+
+    shoot_bullet
+    @shoot_timer = 0
+  end
+
+  def take_damage
+    @hp -= 1
+    @image = @animation[@hp - 1]
+  end
+
+  private
+
+  def shoot_bullet
+    dist_x = @gamespace.player.x - @x
+    dist_y = @gamespace.player.y - @y
+
+    bullet_angle = Math.atan2(dist_y, dist_x) / Math::PI * 180 + 90
+
+    dist = Math.sqrt(dist_x * dist_x + dist_y * dist_y)
+
+    ticks = dist / VELOCITY
+
+    BulletTurret.create(@gamespace,
+                        zorder: ZOrder::GAMEOBJECT, x: @x,
+                        y: @y, velocity_x: dist_x / ticks,
+                        velocity_y: dist_y / ticks, angle: bullet_angle)
+  end
+end

data/lib/prkwars/warp.rb

@@ -0,0 +1,18 @@
+require 'chingu'
+
+# Class holding the warp effect used whenever an enemy game object
+# spawns somewhere.
+class Warp < Chingu::GameObject
+  trait :effect # fade
+
+  def initialize(options = {})
+    super(options)
+
+    @fade_rate = -8
+    @image = Image['media/warp.png']
+  end
+
+  def update
+    destroy! if color.alpha.zero?
+  end
+end

data/lib/prkwars.rb

@@ -0,0 +1,5 @@
+PRKWARS_ROOT = File.dirname(File.expand_path(__FILE__))
+
+Dir[File.join(PRKWARS_ROOT, '/prkwars/*.rb')].each { |f| require f }
+
+#Game.new.show

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: prkwars
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Marek Pikna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-16 00:00:00.000000000 Z
+dependencies: []
+description: A simple Grid Wars clone made as a project for the Ruby class taught
+  at FIT CTU.
+email: mar.pikna@gmail.com
+executables:
+- prkwars
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/prkwars
+- lib/prkwars.rb
+- lib/prkwars/bullet.rb
+- lib/prkwars/bullet_turret.rb
+- lib/prkwars/enemy.rb
+- lib/prkwars/explosionparticle.rb
+- lib/prkwars/game.rb
+- lib/prkwars/gameover.rb
+- lib/prkwars/gamespace.rb
+- lib/prkwars/modules.rb
+- lib/prkwars/play.rb
+- lib/prkwars/player.rb
+- lib/prkwars/popuptext.rb
+- lib/prkwars/splash.rb
+- lib/prkwars/stalker.rb
+- lib/prkwars/turret.rb
+- lib/prkwars/warp.rb
+- media/background.png
+- media/bullet.png
+- media/bullet_turret.png
+- media/gamespace.png
+- media/myparticle.png
+- media/player_ship.png
+- media/stalker.png
+- media/turrets.png
+- media/warp.png
+homepage: http://rubygems.org/gems/prkwars
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Prk wars - a Grid Wars clone
+test_files: []