An interaction system is all you need to 100x your player engagement.

Making a game is about creating small systems that each solve one problem, then integrating them into a larger system: the game itself.

In this post, I'll show you how to create a flexible interaction system to turn your static world into a dynamic one that players can engage with.

Why You Need This System

After building this system in 2018, I never had to waste time figuring out how to create pickable items, NPCs, or mechanics like buttons, switches, and levers. Now I focus confidently on what kinds of interactive objects I can create and why they would improve my game instead of the how.

As we saw in the 5 Tricks to Enrich Your Game World post, modern and classic games alike are grounded in this single system: from coins and bananas to portals that teleport the player between scenes.

When we talk about interactions, we usually think about how the player will interact with the game: controls, interfaces, technologies. But as soon as games started to offer world exploration, we had to create mechanisms to allow the player character to interact with the world itself. That's when interaction systems were born.

What the Experts Say

The game world isn't just set-dressing. It should be something the player operates, changes, modifies, plays with.

Warren Spector, designer of the legendary game Deus Ex, addressed this in an interview for Gamasutra (now Game Development.com):

Stop building movie sets and make a world we can interact with instead. These things are huge. There are all sorts of things we can do beyond pretty pictures.

— Warren Spector

Building the System

Instead of making static worlds that are just pretty and visually appealing, create dynamic worlds that players can interact with. For that, you'll need an interaction system.

Creating one in Godot Engine 4 is simple. It's a two-sided system with an active and a passive component. The active component detects overlaps with the passive component and triggers the interaction, while the passive component... well, doesn't do anything. We'll call the active element InteractiveArea2D and the passive element InteractionArea2D.

Creating the Interactive Area

First, let's pick an exclusive physics layer for this system. This ensures other systems don't interfere with the interaction system, so we won't have to filter interactions with code like if area.is_in_group("interactive_object") or if area is InteractionArea2D. Go to Project/Project Settings/General/Layer Names/2D Physics and name one layer to make it easy to identify. I picked Layer 4.

Figure 1 - 2D Physics Layer names with Layer 4 set as “Interactions”

Next, create a new scene with an Area2D as the root node and rename it InteractiveArea2D. Toggle off all its Collision/Layer bits and Collision/Mask bits, then toggle on only the Collision/Mask bit for the interaction system, in this case: Layer 4, bit 3, with a value of 8.

Figure 2 - InteractionArea2D Collision setup

If you want to understand how Collision Layers and Collision Masks work, I recommend watching this old video of mine:

Video 1 - A video explaining collision layers and masks

Now, back to the tutorial.

Since this is an interaction system, we need the player to be able to... interact with it. We'll read an input action that, once pressed, triggers the interaction. Go to Project/Project Settings/Input Map and create a new action. You can call it "interact" and set the keys or controller buttons as needed.

Figure 3 - Adding the interact input action in the Input Map menu.

After that, attach a new script to the InteractiveArea2D. In this script, create three signals: one for when the player interacts with this InteractiveArea2D, one for when an interaction becomes available, and one for when it becomes unavailable. These last two are filtered area_entered and area_exited signals that don't pass the area argument.

You'll also disable the _unhandled_input process and sync it to the interaction availability: it processes inputs when an interaction is available and doesn't otherwise.

Inside the _unhandled_input() callback, check if the player pressed the interaction action and emit the interacted signal accordingly. The complete script should look like this:

Figure 4 - The InteractiveArea2D script

With that, we can create the other side of this interaction system: the InteractionArea2D. This goes in the player's avatar scene and triggers interactions with the InteractiveArea2D.

Creating the Interaction Area

Start by mirroring the setup from the InteractiveArea2D, meaning the InteractionArea2D won't have any Collision Mask bits toggled on and will only have Collision Layer bit number 3 toggled on.

Figure 5 - The InteractionArea2D Collisions setup

And... that's it. Just attach it to your player's character body, add a Collision Shape, and voilà!

What You Can Do With This

This was a short how-to post showcasing one of the 16 systems presented in the Godot Platformer Essentials cookbook. Each chapter offers context, pros and cons, references, and design and engineering insights about the system.

Take Your Game Further

Get theGodot Platformer Essentials cookbook and start making interactive worlds TODAY before the price increase. There are only two chapters left to port to the new distribution platform. Join 528 game developers who bought the book and rated it perfect 5-star educational content.

If you want even richer interactions, you need systems that will enhance your adventure: events, dialogues, quests, and saving systems. For that, you can get the Godot Adventure Essentials and learn to create adventure games in Godot Engine within 5 days.

Comment below on how you'll use this interaction system to make dynamic worlds and richer game experiences, and share this post in your Godot community so everyone can benefit from it!

That's it, thank you for your support. Until the next one!

— Henrique Campos