A few weeks ago I wrote a post about the Dragonruby game engine. I mentioned that there was a month-long game jam to make a 20 second game. This post is about my entry: Ghost Trap.
Try it out on itch. If the html version is a little wonky you can download your OS specific version. I tried it on 3 different computers and it was fine on 2 of them, but the older Windows machine could not handle it.
When I was a kid I really liked the Ghostbusters game for the Sega Master System. It's not a great game, but I liked stopping the ghosts from entering buildings, driving and catching the ghosts, and trapping the ghosts at the homes they were haunting. I decided I would make a game that was similar to trapping the ghosts.
In the Sega game, you get to your destination and you have 2 ghostbusters to move. You move one where you want him, then use the other to guide the ghosts between the two of them toward the trap.
I didn't want to make a clone, so I decided to make it so a single "ghostcatcher" catches ghosts in their beam, which get sucked into their backpack. The backpack can only hold 10 ghosts, so the ghostcatcher has to periodically deposit ghosts into the ghost disposal canister. The objective is to trap as many ghosts as you can in 20 seconds. You can earn a combo the more ghosts you catch on your beam at once and your beam energy depletes over time to keep the player from holding the button down the entire 20 seconds. You have to stop shooting to regenerate energy.
Oh yeah, this is a world of dogs instead of people, because why not? Truthfully I didn't want to draw a ghost that looked like a traditional emoji looking 👻 ghost, so I made a dog-ghost. Plus, this gave me an excuse to use my dog Pixel as a reference for my ghostcatcher.
Artwork
I made the art with a combination of Affinity Designer and Procreate on the iPad and Affinity Photo on the Mac. I never used the Affinity software before so I was learning as I went along. Affinity Designer is really cool and I enjoyed working with it once I started to get the hang of it, but I really miss having access to Photoshop which is something I'm quite comfortable with.
Code Organization
I broke my code down into 6 classes and a few helper methods. I think some of the code I wrote was possibly handled by Dragonruby, but since I'm still learning how it all works I didn't take advantage of all of its features.
Entity
The Entity class is the parent for my other game object classes. It has properties for sprite dimensions and attributes, collision, and rendering.
# an excerpt of the Entity class
class Entity
attr_accessor :x, :y, :w, :h, :sprite_path, :flip, :alpha
def initialize(x, y, w, h, sprite_path, flip)
@w = w
@h = h
@x = x
@y = y
@sprite_path = sprite_path
@flip = flip
@alpha = 255
end
def rect
[x, y, w, h]
end
def render
[
x, y, w, h, sprite_path,
0, # ANGLE
self.alpha, # ALPHA
255, # RED SATURATION
255, # GREEN SATURATION
255, # BLUE SATURATION
0, # TILE X
0, # TILE Y
self.w, # TILE W
self.h, # TILE H
self.flip, # FLIP HORIZONTALLY
false # FLIP VERTICALLY
]
end
def is_colliding_with?(obj)
self.rect.intersect_rect?(obj.rect)
end
#... etcc
end
I made the rect method to pass to the built-in intersect_rect to check for collision, but I believe it might be something I could have handled with Dragonruby natively. That's something I have to research further.
Player
The Player class is a subclass of Entity and handles all the player specific stuff like moving, shooting, catching ghosts, etc.
# an excerpt of the Player class
class Player < Entity
attr_accessor :total_ghosts_held, :backpack_limit, :beam, :is_shooting, :ghosts_on_beam, :beam_power, :beam_cooldown, :speed, :is_walking, :sprite_frame, :shoot_sound_playing
MAX_BEAM_POWER = 200
BEAM_COOLDOWN = 1
def initialize
w = 114
h = 300
super($WIDTH/2-w/2, 90, w, h, "sprites/player_green_1.png", false)
@total_ghosts_held = 0 # total ghosts in pack
@backpack_limit = 10
@beam = {x: ((self.x + self.w)/2).to_i, y: self.y+h, h: 300, w: 23}
@is_shooting = false
@ghosts_on_beam = []
@beam_power = MAX_BEAM_POWER
@beam_cooldown = 0
@speed = 6
@is_walking = false
@sprite_frame = 0
@shoot_sound_playing = false
end
def set_sprite
status_color = self.space_in_pack? ? "green" : "red"
self.sprite_path = "sprites/player_#{status_color}_#{self.sprite_frame+1}.png"
end
def calc(outputs, tick_count)
self.sprite_frame = self.is_walking ? tick_count.idiv(6).mod(2) : 0
if self.can_shoot? && self.is_shooting
play_sound(:shoot) if !shoot_sound_playing
self.shoot_sound_playing = true if !self.shoot_sound_playing
self.shoot(outputs, tick_count)
elsif self.has_ghosts_on_beam?
self.shoot_sound_playing = false
add_score(self.total_ghosts_on_beam)
self.store_ghosts_from_beam_to_pack
self.ghosts_on_beam.clear
end
self.refill_beam if !self.is_shooting && self.beam_power != MAX_BEAM_POWER
end
end
Ghost
The ghost class handles spawning ghosts, and each instance can keep track of whether or not it has free will (if it's caught in the player's beam or can move freely) and if it's invulnerable. Ghosts flicker in and out and are invulnerable to being caught if they are transparent.
# an excerpt of the Ghost class
class Ghost < Entity
attr_accessor :is_flickering, :is_invulnerable, :has_free_will, :is_in_beam, :id
def calc(tick_count)
# use different sprite if ghost is on beam
self.sprite_path = !self.is_in_beam ? "sprites/ghost80.png" : "sprites/ghost_on_beam.png"
# keep in bounds
self.y = $HEIGHT if self.y < 0 || self.y > $HEIGHT
self.x = 0 if self.x < 0
self.x = $WIDTH - self.w if self.x + self.w > $WIDTH
self.toggle_flickering if tick_count % 60 == 0
self.flicker if self.is_flickering
self.move_freely(tick_count) if self.has_free_will
end
def stop_flickering
# play_sound(:flicker_in)
self.is_flickering = false
self.is_invulnerable = false
self.alpha = 255
end
def start_flickering
# play_sound(:flicker_out)
if self.has_free_will
self.is_flickering = true
self.is_invulnerable = true
end
end
def self.spawn
x = random_int(20, $WIDTH - 100)
y = random_int(400, $HEIGHT - 100)
Ghost.new(x, y)
end
Disposal
Disposal is the canister where the player deposits ghosts. It keeps track of how many ghosts it contains and its open/closed status to handle which sprite should display.
# An excerpt of the Disposal class
class Disposal < Entity
attr_accessor :total_ghosts, :is_open, :timer
def initialize
super(566, 221, 99, 154, 'sprites/canister.png', false)
@is_open = false
@total_ghosts = 0
@timer = 1
end
def deposit_ghosts(total_to_add)
play_sound(:dispose)
self.is_open = true
self.total_ghosts += total_to_add
end
def calc(tick_count)
self.timer -=1 if self.is_open
self.is_open = false if timer <= 0 && tick_count % 10 == 0
end
def open_canister
self.sprite_path = OPEN[:sprite_path]
self.w = OPEN[:w]
self.h = OPEN[:h]
end
def close_canister
self.timer = 1
self.sprite_path = CLOSED[:sprite_path]
self.w = CLOSED[:w]
self.h = CLOSED[:h]
end
def render
# set sprite based on open status
self.is_open ? open_canister : close_canister
super
end
end
GhostTrap
Finally, there is the GhostTrap class, which is the game class that handles all the game functionality and pieces everything together.
The defaults method sets up all of the properties in state. Normally I would use instance variables, but Dragonruby has a built-in variable called state that is passed from tick to tick.
def defaults
state.player ||= Player.new
state.disposal ||= Disposal.new
state.ghosts ||= MAX_GHOSTS.map { Ghost.spawn }
state.mode ||= :title
state.timer ||= 20
state.score ||= 0
state.countdown ||= 3
end
All rendering (drawing to the screen) are organized within the render method, and all updates are handled within the calc method. User inputs are handled in process_inputs. I broke everything down further depending on what game screen the user is on.
def render
render_title if state.mode == :title
render_instructions if state.mode == :instructions
render_credits if state.mode == :credits
render_play if state.mode == :play
render_game_over if state.mode == :game_over
end
Problems
I had the most trouble working with sound effects. I was able to get basic sound effects working, but I couldn't figure out how to get an effect that wasn't music to loop and stop when I wanted it to. I wanted a whirring effect for the player's beam but I settled for an initial effect each time the player first presses the spacebar to shoot. I did this by adding an additional variable, shoot_sound_playing which I set to true when the player shoots, as long as it's not already true. Then I set it to false when the player stops shooting.
The Dragonruby docs recommend you go through each sample game thoroughly to really learn the engine, so I went through what I could but I didn't have time to really dig into everything. I think if I go back and look through the code when I get a chance I can probably do some refactoring and make some improvements to my game.
if self.can_shoot? && self.is_shooting
play_sound(:shoot) if !shoot_sound_playing
self.shoot_sound_playing = true if !self.shoot_sound_playing
self.shoot(outputs, tick_count)
# ... etc
You can find the full game code on my github
Side note: I know I used self sometimes and not other times. Personally I prefer to use it because then I know exactly where a method is coming from and to me that's more readable, but Dragonruby doesn't use it and I know Ruby is all about being free of clutter. I'm still in the process of cleaning everything up and making it consistent, but I wanted to get this post out asap. :)
Top comments (0)