• Your purchase includes a free PDF copy of this book along with other exclusive benefits. Check the Free Benefits with Your Book section in the Preface to unlock them instantly and maximize your learning experience.

All the code examples for the entire book can be found on GitHub here: https://github.com/PacktPublishing/Game-Development-with-Godot-and-C-.

Plus, to follow along with the book, you will need the following tools:

• The latest version of Godot (currently 4.5.1) installed
• The latest version of Microsoft’s .NET SDK (currently .NET 8.0)
• An IDE (we will be using Visual Studio Code)
• C# extension as provided by Microsoft
• Knowing C# is not a prerequisite to utilizing this book, but knowing programming fundamentals and the Object-Oriented Programming (OOP) paradigm will be essential

Let’s get those tools now.

Installing Godot 4

Download the Godot Engine, specifically Godot 4, by accessing this page: https://godotengine.org/download. The web page will auto-detect your operating system and present you with two download buttons – just Godot Engine and Godot Engine - .NET. We want the second option, which has C# support, so make sure to click that one.

Figure 1.1: The download web page for Godot 4

After downloading the correct version of Godot, all that’s left to do is extract the .zip file. Godot does not include an installation, so once the file is extracted, you can run it immediately with no additional setup.

Next, we will look at downloading the .NET SDK.

Downloading the .NET SDK

Alongside the .NET version of Godot, you also need to have Microsoft’s .NET SDK. This will provide you with the Microsoft Build Engine (MSBuild) to compile the project we will build. MSBuild is what creates our .csproj file within our project and allows us to compile our code.

Download the latest stable version of Microsoft’s .NET SDK from here: https://dotnet.microsoft.com/en-us/download.

Choosing an environment

While Godot has a built-in editor for writing scripts, it’s best to download your own integrated development environment (IDE) or code editor when using C#. The biggest difference between an IDE and a code editor is that an IDE has more tools available for development, whereas a code editor is a text editor for code. For more information on supported IDEs and editors, visit https://docs.godotengine.org/en/stable/engine_details/development/configuring_an_ide/index.html.

For this book, I will be using Visual Studio Code (a code editor) and will walk you through how to set it up. You can download Visual Studio Code here: https://code.visualstudio.com/. Once installed and launched, you will need to configure it for use with Godot. Click on the Extensions button on the left-hand side (it’s right below the Debug button that looks like a little bug with a play button). The button that has the blue two on it in Figure 1.2 is the button to click.

Figure 1.2: The toolbar on the left-hand side of Visual Studio Code

After opening the Extensions page, type C# in the search bar, and you should see a list of options come up. Select the one that says C#, making sure the creator is Microsoft, and click Install.

Figure 1.3: The C# extension page

With all the tools needed to begin programming in Godot, let’s take some time to understand what the Godot Engine is and why it’s useful.

The Godot Engine is a robust game engine that’s ideal for creating 2D and 3D games. It was created in 2007 by Juan Linietsky and Ariel Manzur; however, since its inception, many people have contributed to the engine, as you can see from the long, awesome list on the GitHub repository: https://github.com/godotengine/godot/blob/master/AUTHORS.md.

Since it is free and open source, it comes at no cost to you as a developer, and the source code is readily available to be modified or updated at any time. The license that Godot operates under is the MIT License, which is also commonly known as the Expat License; it puts development in the hands of developers and leaves it there.

In terms of function, Godot is flexible and easy to set up. You can download the engine on a USB drive and run it with no problem. If there’s a feature you don’t like, you can modify the source code yourself, or if there is a feature you like, you can continue building on it and open a pull request about it to the Godot community. If you like it, you may find yourself becoming a contributor to the engine too, which we’ll discuss in Chapter 12.

The biggest drawback to this system, however, is that if a feature is not frequently used or kept up with development, it can be removed in a newer version. A good example of this is VisualScript, a visual scripting language for Godot, which was removed in Godot 4. The team has said that this may be reconsidered, but only as an extension, not a core feature of the engine. While this may seem like a negative, it can be a great boon in keeping the community engaged by providing valuable feedback on valued features.

Don’t let that draw you away from Godot, though, as it has a myriad of powerful features that make it a versatile engine. The following are just a few of those key features and how they make Godot convenient to use:

• Lightweight: Downloading the Godot Engine is not only easy, but it’s fast due to it being so small. The entire engine is barely over 100 MB, and as I said, it can fit on a USB drive.
• Supports multiple languages: Program in the integrated scripting language GDscript, use the recently added C# bindings, or any other number of programming languages supported by the community, such as Rust.
• Git-friendly: Godot uses a friendly and readable filesystem that makes it easy to create and maintain projects in places such as GitHub.

Overall, the Godot Engine is an excellent choice for both beginner and veteran developers. It’s intuitive and easy to pick up, but due to its open development nature, features and upgrades are constantly being implemented to provide Godot depth and a wide array of capabilities that compete with other commercial engines.

With a better understanding of some of Godot’s benefits, let’s take a look at how it functions as a game engine.

What makes Godot unique is its scene system and node structure.

The scene system is the space where nodes are housed. Each scene is made up of nodes, and everything created in Godot is derived from the Node object. Nodes are the building blocks of our scenes and how objects are created in Godot.

The scene structure becomes a tree of nodes, as shown in Figure 1.4:

Figure 1.4: Scene hierarchy in the Godot Editor with an example node tree

For example, let’s say we want to create a first-person character. It requires attributes such as a kinematic body, collision shapes, and cameras (if you don’t know what these are, that’s okay, we’ll learn about these nodes in later chapters).

Each of these attributes would be a different node and, collectively, they would make a scene. In the previous figure, there are seven nodes in the current scene. Depending on the type of node that’s present, there is a different icon next to the node’s name. Let’s break down each of these nodes, starting from the top and working our way to the innermost node:

• Player: The root of this scene tree, the Player scene, is the Player node, which has a running figure icon to indicate that it’s a CharacterBody3D node.
• CollisionShape3D: This node provides a collision layer to our player object and is a child of the Player node.
• Body: The Body node is a PackedScene with nodes for the Player model attached to it, including all the pieces needed to animate it. This node has the symbol for a Node3D object (a red circle), but also notice the clapperboard icon to the right of the name of the node. This means this node is a PackedScene node, which means it’s serialized. Serialization here means all the information relating to the scene has been converted from data types to bytes efficiently.
• Camroot, h, and v: These next three nodes are all Node3D objects and were created to control the position and movement of the Camera by script. There is a script attached to the Camroot node with a little scroll icon that’s next to the node name. Camroot is the base of the camera; h and v represent horizontal and vertical movement, respectively.
• Camera: The innermost nested node is Camera, which has a camera icon next to it and allows us to create either a first- or third-person view of the player, depending on where we position the Camera.

Using the scene system allows developers to easily create prefabs out of nodes. There’s no additional step to save this scene as a prefab; we can simply take Player.tscn with all these nodes on it and drag and drop it into another scene. This ability is the biggest distinction Godot has from other game engines, because it allows fast prototyping.

With the scene structure in Figure 1.4, we can see some important patterns that you may or may not be familiar with. Let’s briefly cover them here:

• OOP: Another way to think about the scene system is in terms of Object-Oriented Programming (OOP). When a system, or language, is OOP, it means that everything is derived from objects, and within those objects, you have your attributes and can modify them within the object. If you’ve used an OOP programming language before (such as C#), then transferring that knowledge to Godot will be very intuitive. We see this in the scene structure in Figure 1.4 as well as the fact that everything in the scene derives from one object, a node.
• Inheritance: The other piece of Godot that goes together with the OOP paradigm is inheritance. Inheritance is just what it sounds like – an object inherits attributes from another object. Just like in our previous node tree, each node below another node inherits from its parent node.
• Polymorphism: Another important concept to know when using Godot is polymorphism. To understand how this works in Godot, let’s consider a new scene that our player might pick up called Item. In the Item scene, we’ll have a shape, collision, and the item model. If we wanted to have other item types have the same base properties, we could extend the Item scene to be used by any type of Item we wanted. While it may not be clear here, we will use this concept in Chapter 5 when creating our world.
• Composition: The last idea we’ll briefly discuss is composition, although it is not featured in Figure 1.4. This is something Godot does extremely well and should be used whenever possible. It goes hand in hand with an idea we’ll discuss in Chapter 3, which is cohesion and coupling. Let’s use an enemy as an example. Say we want our player to have Health and Armor. The Health would be its own scene, as would the Armor. These scenes would be named HealthComponent and ArmorComponent, respectively. Then, whenever we wanted to add either Health or Armor to an enemy, we could attach HealthComponent or ArmorComponent without needing to recreate everything. If this is still confusing to you, you can read more about it here: https://docs.godotengine.org/en/stable/getting_started/introduction/godot_design_philosophy.html.

Now that we’ve got a brief understanding of how the Godot Engine works, let’s start navigating through it.

The next section will take some time to explain each component of the editor and their names. We’ll also briefly discuss how each of those components is used in a project.

When you first launch the Godot Engine, you’ll be greeted by the Project Manager screen, as shown in Figure 1.5:

Figure 1.5: The Project List screen when launching Godot

Here, you can create, import, rename, remove, or delete projects. Click the New button and choose a name for the project. Godot will make sure you choose an empty folder, so all our project files will be housed in one location.

Once a project is created, Godot will take you to the editor screen. The default layout looks like this:

Figure 1.6: The Godot Editor in use

We’ll go over each section individually.

Scene/Import docks

The Scene/Import dock (1 in Figure 1.6) sits in the top-left corner of the engine, right below the menu bar. There you’ll see two tabs – Scene and Import. We saw a close-up view of this dock in Figure 1.4 when talking about Godot’s node structure and scene system.

The default view of this dock is on the Scene tab, which shows the node structure of the current scene open in the Viewport. Selecting 2D or 3D from the screen buttons (3 in Figure 1.6) changes the views accordingly; as seen in Figure 1.6, the 3D view is selected.

Within the 3D view, you can select a specific axis to view objects on by clicking either the colored X, Y, or Z axes on the axis gizmo that lives in the top right corner of the Viewport. You can also click and drag the axis gizmo to view objects at a specific angle or at the intersection of two planes.

The second tab in this dock is the Import tab. As you might expect, it’s related to examining the specific properties of resources. Resources are everything from 3D models to music to user interface images. Depending on the type of asset it is, there will be different properties to adjust and change as needed for your project. At the bottom of the Import tab, there is a Reimport button for when you’ve made changes to an asset and need to reimport it with different settings.

Viewport and screen buttons

The Viewport (2 in Figure 1.6) is in the center of the screen and the largest part within the Editor. This is where you’ll see the results of the scenes that you create.

At the top is a screen navigator (3 in Figure 1.6) where you can toggle between the 2D, 3D, Script, and Asset Library screens. Clicking Script will show the scripts available in the opened scene, and clicking the AssetLib button will take you to Godot’s Asset Library, where you can find useful third-party plugins or create your own to be added there!

FileSystem dock

The FileSystem dock (4 in Figure 1.6) sits in the lower left-hand corner of the Viewport and represents the file structure of your project. Godot and its community don’t have a recommended file structure when creating projects, mainly because there are no restrictions when structuring them, but they have some general information about how Godot interacts with the project structure. You can find more about it here: https://docs.godotengine.org/en/latest/tutorials/best_practices/project_organization.html#organization.

The example structure in Figure 1.7 is a common one that’s used in other game engines. While it’s a viable format, we’ll discuss other ways to structure your project in Chapter 3.

Figure 1.7: An overview of the file structure I use for my Godot projects and will use for this book’s project

The only general rules when it comes to creating your file structure are as follows:

• Use pascal_case for folder names and filenames
• Use SnakeCase for nodes and scenes
• Include an addons folder for plugins and other third-party pieces

Though there is no standardized way to structure a project in Godot – it should be whatever works best for you – make sure to keep these rules in mind when creating your own file structure.

Inspector/Node/History dock

The Inspector dock (5 in Figure 1.6) has three tabs:

• Inspector: By default, this is the visible tab. Here, you can see the details and properties of a selected node, including its scale, transform, and rotation. The information listed here will vary based on the type of node selected, but it will be an extremely useful space to reference as we work in Godot.
• Node: Much like the Inspector, this tab shows the signals you can implement based on the selected node, and provides a space to manage your groups. Signals and groups will be components we cover in Chapter 4.
• History: This tab is exactly what you’d expect it to be. It’s a history of the actions you take in the project. You can limit the actions to be tracked by scene or globally. For example, if you moved an object in a scene, the History tab would add a log line. This would track the change much like you can do in a document. It’s a convenient tool for understanding what actions you took during any given development session.

Bottom panel

The final panel we’ll cover is the bottom panel (6 in Figure 1.6). This panel has multiple buttons running along the bottom of it:

• Output: Provides a log of debug statements, errors, and warnings.
• Debugger: This is where you’ll see more detailed error messages and can monitor resource usage.
• Audio: This is where you can add audio buses, apply audio effects, and augment the levels of each audio bus.
• Animation: The animation player allows you to preview animations, add bezier curves, and manage other animation components.
• Shader Editor: Here, you’ll write your shaders. Godot uses a shader language very similar to GLSL, so if you are already familiar with it, it will be easy to transfer to Godot.
• MSBuild: This is the Microsoft Build Engine, and you can build your C# project from here. You can also see any warnings or errors when the MSBuild occurs.

With that, you have learned what the main components of the Godot Engine interface are and how they work together. While we didn’t create anything within this project, this will be the project we use throughout the rest of the book.

In this chapter, you learned what the Godot Engine is and some of its history. You also learned about the different parts of the Godot Editor and how each of them functions individually. Now that you’re familiar with the various pieces of the Godot Engine, we can look at how C# functions in Godot.

In the next chapter, we’ll discuss how C# behaves in Godot, including some of the unique rules that we’ll need to follow for the programming language. At the end of the chapter, we’ll create a simple 2D script in C# to better understand the workflow of C# in Godot.