Game programming is a challenging and rewarding field, but it also comes with its share of bugs and errors. How do you use logging and error handling to track and resolve game issues? In this article, we will cover some of the best practices for debugging your game code and improving your game quality.
Logging is the process of recording information about the events and actions that occur in your game. Logging can help you identify and diagnose problems, measure performance, and monitor user behavior. Logging can be done in different ways, such as using print statements, writing to files, or sending data to a remote server. Depending on your game engine and platform, you may have access to different logging tools and libraries. For example, Unity provides a built-in console and a debug class, while Unreal Engine has a log window and a log macro.
Be sure that your logging is clear and to the point, with any relevant data included. When sending logs or telemetry to remote servers for storage, it's important to make sure that the logs are well formatted for any later processing that may be needed. JSON is a popular format for these use-cases. In debuggers, take advantage of text formatting and methods (in Chrome) like console.table() to make the logs easier to digest at a glance in order to reduce debugging time.
Logging serves as a breadcrumb trail of events within your game, providing invaluable insights into its runtime behavior. Establish a robust logging framework that captures critical events, such as initialization, user interactions, and state changes. Utilize log levels (e.g., INFO, DEBUG, WARN, ERROR) to categorize messages based on their severity and relevance. Implement logging libraries or frameworks tailored to your game engine or platform for streamlined integration and management.
Adding logs to your code will help you to find bugs and issues and fix them. As a Unity programmer, I use the built-in console every day while I am programming, but I recommend removing all the logs when building your game to be published because they will decrease the performance of your game. To have information of your published game, I recommend sending data to remote severs, using tools like Crashlytics or Bugsnag.
Make logs or errors actionable: write sentences that tell the reader what is wrong AND what to do. Also log the actual vs expected values that triggered the log.
Error handling is the process of responding to unexpected or invalid situations in your game code. Error handling can prevent your game from crashing, freezing, or behaving incorrectly. Error handling can be done in different ways, such as using try-catch blocks, assertions, or custom exceptions. Depending on your game logic and design, you may want to handle errors differently. For example, you may want to ignore minor errors, display a warning message, or end the game gracefully.
Effective error handling is the cornerstone of robust game development. Implement a comprehensive error handling strategy that encompasses both anticipated and unexpected errors. Use try-catch blocks, assertions, and defensive programming techniques to detect and handle exceptions gracefully. Design error messages that are informative, actionable, and user-friendly, guiding players and developers towards resolution steps or workarounds.
The most critical area in error handling is ensuring errors are propagated and not just silenced. If action needs to be taken care of, it's best to re-throw the error so the controller can handle it at the highest level and can return or display the appropriate message to the user or the response API. This can help also in generating a trace because a fuller path can be logged.
Many C++ code base are exception averse so avoid designing code that relies on exceptions. Errors : check Absl StatusOr , it is a nice API to return status or errors. Propagate them as necessary. If you really can’t recover assert early (hint: you often ca; don’t be lazy). Asserts should be used VERY carefully as they often either are totally useless because no one runs debug builds OR they are activated in release and in that case they can cause outages/crashes (we all hate when editors stop because of an assert and we loose work: don’t be the person who added that assert. )
Debugging is the process of finding and fixing errors in your game code, and can be done using breakpoints, step-by-step execution, or watch expressions. Depending on the game engine and platform, you may have access to various debugging tools and features, such as Unity's visual studio integration and mono debugger, or Unreal Engine's visual studio code integration and blueprint debugger. To make the most of these tools, it’s important to use descriptive and consistent naming conventions for variables, functions, and classes; comment and document code logic and purpose; log errors to capture relevant information; use debugging tools to inspect and modify game state and behavior; and use testing and debugging modes to simulate different scenarios.
Logging and error handling are indispensable pillars of game development, providing developers with the visibility, context, and insights needed to track and resolve game issues effectively. By implementing logging best practices, robust error handling strategies, centralized reporting mechanisms, and a commitment to continuous improvement, developers can navigate the complexities of game development with confidence and deliver exceptional player experiences.
I like to add debug logs to first understand how the system I'm debugging works. Then I pinpoint my debug logs to specific areas I think the issue might reside in.
In C++ I often like to use “static volatile” local variables to test code path or enable specific custom code (volatile tells the optimizer not to assume anything about the variable and read the value from memory, which will let you modify the value through the debugger). This can avoid unnecessary recompilation or let you toggle code on the fly to compare behaviors.
Many developers overlook the full potential of their IDE when debugging game code. Breakpoints are a great example. If you're dealing with a complex bug or need to delve deeper into your game's logic, try running your project in debug mode and adding breakpoints anywhere in your code. Even better, breakpoints can be conditional—you can set rules to pause execution only when specific in-game values meet certain conditions. This can save a lot of time and effort! Another powerful trick is handling infinite recursion loops. Run your code in debug mode, and when you encounter the issue, press the Pause button in the Debug panel. The IDE will halt execution, letting you inspect the problem and resolve it quickly.
Testing is an essential process for verifying and validating game functionality and quality. It can help you find and fix bugs, improve game performance, and enhance user experience. Testing can be done in different ways, such as using unit tests, integration tests, or beta tests. Depending on your game scope and complexity, different testing methods and tools may be necessary. For example, Unity provides a test runner and a test framework, while Unreal Engine has an automation system and a test suite. When it comes to best practices for testing your game code, you should use test-driven development to write code based on test cases and requirements. Additionally, testing tools and frameworks can help automate and simplify the process. It’s also important to use testing levels and types to cover different aspects and layers of your game, as well as testing metrics and feedback to measure and improve game quality.
Debugging is a skill that requires practice and experience, and there isn't a single solution for debugging game code. To help you learn and improve your debugging skills, we recommend the following resources: Debugging Game Programming: A Practical Guide by Paul R. Cohen and Mark Cohen, Game Debugging: The Complete Guide by Luis Anton, Game Programming Patterns by Robert Nystrom, Debugging with Visual Studio Code by Microsoft, and Debugging with Unity by Unity Technologies. This article has given insights into how to use logging and error handling to track and resolve game issues. Debugging is an essential part of game programming and can make or break your game; therefore, it is important to follow best practices for debugging your game code in order to create more robust, efficient, and enjoyable games.