My entry into game design was through programming. I am a "programmer first- designer second" game developer where all my games starts with creating systems.

I've always wanted to create a puzzle game with elegant mechanics that interact with each other to create systemic puzzles. I started with a setting, artstyle and theme in mind, then started prototyping the project.

After creating some mechanics I set out to make my first puzzle and failed immediately. I could not figure out how these mechanics could interact in an interesting way.

I took a look at some of the inspirations for my game and tried to come up with some guidelines to help me create solid puzzles.

Creating modular systems

The concept of Composition over Inheritance is vital when creating a puzzle game. Lets say I have an enemy I want the player to be able to attack. One solution to this is to add an "Attack" method to the enemy Component, and call that when a hit occurs. It works perfectly, but what happens if I want the player to be able to attack other objects than an object with the Enemy component on it? This is where composition comes in.

I can create an IAttackable interface that all objects I want the player to be able to attack can inherit.

IAttackable.cs
public interface IAttackable
{
    float Attack(AttackInfo attackInfo);
}

This can then be inherited by multiple components that can implement this in different ways. Maybe you want a box to move when it's attacked? Or creating a generic Killable object that fires events when it's been hit X times.

The same concept can be applied to other events as well, for example Interactables, Activatables, Reflectables and so on.

Making sure the modular systems can interact with each other

Creating these systems with the intent of them being able to interact with each other takes this to the next level. It creates so many possibilities when for example both the player and the enemy can push boxes by attacking. Or when a projectile can click a button.

It's worth noting that keeping these systems closed and small is important to make sure they behave like they should. Smaller systems have less scope and are both easier to integrate with other systems and are less likely to have bugs.

The mechanics-grid

A technique to systematically come up with mechanic-interactions is to create a matrix that shows all mechanics interacting with each other.

Mirror Turret Slime
Rotator pad New Mechanic! New Mechanic! New Mechanic!
Turret New Mechanic! New Mechanic! New Mechanic!

Creating a matrix of all the mechanics will generate even more complex mechanics.

Here are some examples taken out of the grid above:

Rotator Pad + Mirror

Activating a rotator pad will turn the mirror 90 degrees. This could be an interesting mechanic to introduce, for example to change the way a projectile is reflected, or change which direction your player can use the mirror to teleport.

Turret + Slime

Luring a slime into an auto-firing turret could be an interesting puzzle mechanic. One could take this one step further by learning from the previous example: rotate the turret such that the projectile can be used to kill the slime.

Adopting a programmer's mindset when approaching puzzle design can introduce a systematic and effective approach to creating engaging gameplay scenarios. By focusing on modular systems, you lay the groundwork for building intricate mechanics that can seamlessly interact with one another.

More posts