Godot 4: Advanced Game Development

Do you want to take your indie game development to the next level?

Discover the complete process of game development in Godot Engine, including preparation, creating simple assets, building complex UI, expanding with new features, and finally publishing your game on the Steam platform. All of this is based on personal experience and many years of practice in the field.

The e-book has more than twice as many pages as the first volume and offers a fresh perspective on many of the techniques we use when creating games in Godot.

With the book, you also get the complete project source code, including assets.

Once you purchase it, you'll get lifetime access to all future versions!

The book is based on this game: Beyond The Space Wall

Sample pages:

What does this book cover?

1. Blender to Godot pipeline: The first chapter explains the reasons why we decided to use Blender for creating assets. It describes the basic principles of low-poly modeling and the advantages of this approach in games where we expect a large number of moving objects in the scene. It explains the benefits of skinning with external materials and guides the reader through modeling three basic assets for the game. Finally, it describes the export process, optimized for maximum compatibility with the Godot Engine.
2. Project and import: Here we will learn how to create a new Godot project, including the basic setup of project settings and the design of the folder structure. We will demonstrate how to import Blender models in a way that is compatible with the latest versions of the Godot Engine. We will obtain materials from the Material Maker application or create our own and assign them to models using triplanar mapping.
3. State and layers: This section describes a general system for defining and maintaining the game state, which we will later save to a file. It demonstrates UI design using layers and their integration with various game events. In addition, it reminds us how we localized the game in the first book and adds automatic language detection based on the operating system settings.
4. The scene structure: The chapter provides a description of the four basic scenes on which the game is built: splash screen, main menu, wall selection, and gameplay. It demonstrates a new way to force shader compilation at startup or how to deal with embedded mode. It explains the advantages of a dynamic splash screen and prepares the game for mouse, keyboard, and controller support. The chapter shows the importance of a rough sketch for UI design and explains the use of the theme editor for a consistent look throughout the entire application.
5. Shared building blocks: Here we’ll look at components that we’ll be able to use in different parts of the game thanks to the layer system. These include a useful debug layer, settings, HUD, and audio system, as well as a new pause menu that makes pausing the game much more flexible. And as a bonus, we’ll demonstrate how to define shortcut icons so that they are compatible with the most widely used controllers.
6. The game logic: In this section, we’ll bring to life everything we’ve created so far in a static state. We’ll define layers and masks for handling collisions and implement some specific cases, especially when it comes to the ball colliding with other objects. We’ll demonstrate how pause mode actually works and add graphical effects that will be frozen in time during such a pause. Finally, we’ll create a system for automatically saving and restoring the game state.

   

7. Power me up (or down)! The chapter focuses on creating and using power-up objects, through which we’ll add a new dimension to the game’s logic. It describes modeling falling elements in Blender, importing them into Godot, and handling the object’s interaction with the paddle. We’ll learn how to use a general system for managing power-ups and the bonuses derived from them. Through several examples, we’ll demonstrate how specific bonuses can work directly in the game and what to watch out for when activating or deactivating them.
8. Tips, tricks, and tools: In this section, we’ll focus on several tools that can greatly simplify different aspects of development. Some I created myself (sprite generator, screenshot saver); others are part of Blender (cracked bricks) or Godot (complex emission shapes). In addition, we’ll learn about the collision system and how to modify it to handle certain unusual situations.
9. What did we leave out? We’ve brought the game to a playable state, but it’s still missing something. So we’ll add an improved controller system, flying enemies with various defined behaviors, difficulty selection for the game or UI, and the implementation of a talent tree. Finally, we’ll tackle the dialogue and code responsible for manual saving and restoring of the game state.
10. Release - before and after: Releasing a finished game can be a more complex process than it might seem at first glance. We’ll explain the difference between running a game from the Godot editor and a standalone EXE file. We’ll describe how to detect and fix bugs that only appeared after exporting the game. Not only that, but we’ll get acquainted with the process of preparing a game for the Steam platform and how to integrate the Steam API into our code. Furthermore, we’ll use this for synchronizing the game state with Steam Cloud and implementing the first achievements. Finally, we’ll show how to connect the Steam Deck with the development environment so we can test the game on this console as well.
11. More game ideas: In the final chapter, I’ve included thoughts, tips, and reflections that came to me while creating my own game of this type. Some suggestions are supplemented with short code snippets as a practical demonstration of specific functionality.

More sample pages: