Debugging in Game Design

Game Designer at RetroStyle Games | Jan 29, 2024

People make mistakes, and this happens in programming too. These mistakes in programming are called bugs. Debugging is the way to find and fix these bugs.

As the author of the YouTube channel BMo says:

“This time when you play the game, for some reason, you’re just able to shoot this enemy over and over and you know they’re not dying, you’re not even really sure if they’re taking damage”

Does that sound familiar? Then your game definitely needs debugging, god dammit.

What is the process behind debugging a game? There are different types of bugs.

Syntax bugs are like small typing errors in the code, which are often easy to find.

Logic bugs happen when the code does something wrong, like mixing up “if (x > 0)” with “if (x < 0)”, which makes the program act up.

Design bugs are trickier; they happen when each part of the program works fine alone, but not when they work together, showing a problem in the overall plan. There are many other kinds of bugs too.

How to debug a program? Programmers have made lots of tools to help find and fix bugs. Some tools are really smart and can check lots of code by themselves to find bugs. Others are simpler, like memory probes, which need someone with skills and time to use them, but they can tell a lot about why a program is not working well. These tools show how programmers are always trying to get better at fixing the mistakes in programming.

Fixing bugs in games can be tricky and takes a lot of time because games can be complex. That’s why a lot of developers need game testing services.
These services have experts who are really good at finding and fixing bugs. If a game has too many bugs, players might get annoyed or stop playing altogether. And, of course, no game maker wants their game to be known for being glitchy. So, fixing these bugs before the game reaches the players is a big deal.

So, how to debug a game?

We have special game testing solutions that help game makers sort out the bugs in their games.

This way, the games can be the best they can be, and players have a great time playing them.

Debugging is a key part of making games awesome, and when game makers need a little help, our services are there to lend a hand.

What Game Design Debugging Tools Do We Have?

In game development services, there are some cool tools that help fix problems (or bugs) in games.

Here are a few examples that make debugging easier:

Visual Studio. It helps you see what’s going on in your game’s code and graphics. You can pause the game at certain points and check out what’s happening, which is great for finding and fixing bugs.
JetBrains Rider. JetBrains makes tools that help with coding, and Rider is one of them. It’s good for .NET development, which is a type of technology used in some games. Rider likely has strong features for finding and fixing bugs, just like other JetBrains tools.
GameMaker Studio 2 Debugger. This is part of GameMaker Studio 2, it has features like breakpoints, which let you pause your game to see what’s going wrong. It also lets you watch and change what’s happening with the game’s variables as it runs, which is super helpful for debugging.

These tools are great for game developers because they help find problems in games and fix them, and answer the question of how to get debug more efficiently. What else should you consider?

How WE do it (Debugging example from our project)

In our company, we use JetBrains Rider.

How we do debugging as an example: by using code breakpoints.

What does it mean? We pick a spot in the code, set a breakpoint there, and when the game starts running this code and reaches that line, it pauses. Then, you can go through the code line by line, watching how your app works and checking the values of different parameters to see what’s going on.

Rider also lets us set a conditional breakpoint. This means the code doesn’t stop every time it gets to a certain line. It only stops if a specific condition we set is met. Think of it like your bookmark only stopping you if the page has a picture on it.

Using this tool, we can look really closely at all the values of all the parameters and debug symbols and see how they change. That’s mainly why we often use breakpoints and Rider in our debugging process.

Debug Techniques in Game Development

Debug techniques in game development are ways to find and fix problems in video games. Since games can get pretty complicated, these methods are really important to make sure the game works well and is fun to play. To debug your game effectively, you need more than just the right tools; you also need to use some smart troubleshooting techniques.

Debugging method via console

Debugging through the console is an old-school but effective method in game development. It’s like a technique our ancestors might have used a long time ago, but it still works great! To debug in Unity, we use the Debug.Log() command to send messages to the console. This way, we can track various parameter values while the game is running, without stopping it. But sometimes, there can be too many log messages.

In those cases, our Unity debuggers use Debug.LogError() to make certain messages stand out in the console. This method is handy because, unlike breakpoints, it doesn’t stop the game. You can still see how the game got to a certain point by checking the order in which methods were called.

But remember, it’s important to clean up these commands later. If you don’t, your console can become cluttered, making it hard to find what you’re looking for. And you wouldn’t want random “Hello“ or “HHHHHdfhgslhfgkhj“ messages popping up during game testing. However, sometimes these forgotten logs can turn into inside jokes.

For instance, in our game Last Pirate, we have a bug message saying “Kraken is not an enemy” that shows up whenever Kraken appears. No one wants to remove it now; we even think of making t-shirts with this phrase! Also, if you’re looking for an iOS game development company, check our article about our iOS game development.

Debugging in builds of the game itself

Debugging in the actual game builds, especially for mobile games, can be tricky since bugs might not show up in the editor but cause issues on the phone. Here’s how it’s done:

Popup Messages with Error Data. When a bug occurs in the game on your phone, we can set it up so that a popup appears with all the necessary information about the error. This way, even when playing the actual game on your phone, you can get a detailed message telling you what’s going wrong.
Android Logcat with Unity. This is a Unity tool that lets you see console messages from your Android phone when it’s connected to your computer. It’s like having a direct line to your phone’s brain – you can see all the errors and messages from the game on your phone, right on your computer screen. If you need, you can read more about our Android game development services.
Custom Utilities for In-Game Console. We use tools like SRDebugger, which allows us to add a console that can be opened right in the game. This is really handy because it means you can check what’s happening in the game’s code while you’re playing it.

Each of these methods helps us track down and debugging games, ensuring smoother gaming.

Reproducing the Bug

Reproducing a bug is like making sure you can make the same mistake happen again on purpose. It’s really important because if you can’t make the bug happen again, you won’t be sure if you’ve really fixed it. Understanding why something isn’t working is key.

Sometimes, the problem isn’t just in the part of the code that seems broken but might be due to a bigger issue somewhere else in the code.

Best Practices from our team

Our team’s best practices can be seen in the development of a popular adventure-action game. Shortly after its release, players reported a bug on a certain level where the character would mysteriously fall through the floor and get stuck, making further progress impossible.

Initially, our developers tried to replicate this bug. They played through the level many times, using different characters and on various devices, but the bug didn’t show up. However, after carefully analyzing player feedback and videos sent by those who encountered this error, the developers noticed a pattern. The error only occurred when the character interacted with a specific object in the game while performing a unique combination of movements.

Once the bug was reliably reproduced, our development team was able to modify the collision detection algorithms in the game’s physics engine. They thoroughly tested the fix in different scenarios to ensure it solved the problem without creating new ones, and the bug was successfully fixed. Perhaps, if there were a prototype, the bug would be found long before the release. For expert assistance in game development, including prototyping, you can hire game prototype designers.

Hiring such designers is important for game development because they:

Turn game ideas into something real early on, so you can see how they work and make changes easily.
Test and improve gameplay.
Get feedback from others to make the game better.
Follow a step-by-step process to make sure the game is ready for players.
Use special tools to create the game’s prototype.

Wrapping Up about Debugging for Games

Testing and debugging are not done once and forgotten. They are ongoing processes that need constant improvement. To make your testing and debugging better, you can:

Have other testers review your work and give feedback. This is called peer review.
Listen to feedback from users and use it to improve your testing and debugging.
Use metrics like the number of test cases or how much of the code is tested to see how well your testing is working.
Also, use metrics like the number of errors found or how long it takes to fix them to see how effective your debugging is.

By regularly looking at and making your testing and error handling better, you can improve your skills and get better results.

Debugging in games is important because it’s a skill that good programmers need since they often have to find and fix mistakes in the code. But it’s also important to know that having well-organized code and a clear project structure makes debugging much easier.

So, successful debugging in game development depends on both quickly spotting errors and having a well-structured project. For this, you’ll definitely need a professional game debugger. We wish you good luck with your project debugging.