Ghost Trap: My TeenyTiny DragonRuby MiniGameJam Entry
Tags: dragonruby, ruby, gamedev, gamejam
Published: 2020-11-30 04:16:46

---
title: Ghost Trap: My TeenyTiny DragonRuby MiniGameJam Entry
published: true
description: About my TeenyTiny DragonRuby MiniGameJam Entry
tags: dragonruby, ruby, gamedev, gamejam
cover_image: https://github.com/robotspacefish/blog-photos/blob/master/ghost-trap/cover.png?raw=true
---

A few weeks ago I wrote a [post](https://dev.to/robotspacefish/getting-to-know-the-dragonruby-game-engine-263h) 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](https://robotspacefish.itch.io/ghost-trap). 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](https://www.youtube.com/watch?v=vdllC3DD_dc&feature=emb_logo). 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. 
 
<center>
	<img src="https://github.com/robotspacefish/blog-photos/blob/master/ghost-trap/ghost80.png?raw=true" alt="ghost dog" />
</center>

<center>
	<img src="https://github.com/robotspacefish/blog-photos/blob/master/ghost-trap/player.gif?raw=true" alt="Ghostcatcher Pixel" />
</center>

## 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.

<center>
	<img src="https://github.com/robotspacefish/blog-photos/blob/master/ghost-trap/screenshot01.png?raw=true" alt="Gameplay screenshot" />
</center>


## 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.

```ruby
# 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.


```ruby
# 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.

```ruby
# 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.

```ruby
# 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.

```ruby
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.

```ruby
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.


```ruby
 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](https://github.com/robotspacefish/ghost-trap)

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. :)