Stories by Christine Coomans on Medium

Godot 4: The Book of Code

Christine Coomans — Sun, 26 Oct 2025 17:26:59 GMT

If you’re eager to dive into the exciting world of Godot development, it’s important to get a handle on the basics of programming! You don’t need to be a coding wizard to make a game, you just need to have a solid understanding the key concepts like variables, functions, loops, and arrays.

I previously put together the Book of Nodes (which I’m currently updating), covering the common nodes you’ll encounter on your game development journey. I thought it would be super helpful to create a companion resource — a friendly coding guide!

This guide covers the fundamentals of coding in Godot. We won’t delve into all the aspects of coding or GDScript, but we will cover the core structures necessary to begin coding.

What is GDScript?

GDScript is Godot’s own programming language, made just for games. It’s easy to read, beginner-friendly, and designed to integrate tightly with the Godot Editor.

Why use GDScript?

It’s simple, fast, and built for Godot.
It’s similar to Python (clean syntax, no extra symbols).
You can write code directly on any node to control how it behaves.

A lot of developers switch over from Unity and therefore codes in Godot using C#. For that reason, we will be covering both GDScript and C# in this resource.

Navigation

This resource is broken down into the following sections:

1. Fundamentals

Variables
Data Types
Constants
Functions
Comments
Scope

2. Logic & Control

If / Else
Match (Switch)
Loops (For / While)
Break, Continue, & Return

3. Collections

Arrays
Dictionaries
Resources

4. Gameplay Mechanics

Signals (Events)
Input
Timers
Physics Process vs. Process
Random Numbers
The Ready Function

5. Object & Scene Control

Instancing Scenes
Accessing Nodes
Inheritance
Export Variables
Groups

6. Bonus: Polish & Organization

Code Style Tips
Debugging
Autoloads (Singletons)

To make it easier to read, you can download the (free) Offline PDF version of this post here.

Part I: Fundamentals

Before embarking on a complex project, it’s crucial to grasp the foundational elements of coding. The Fundamentals section covers the core concepts that you will frequently use in nearly every Godot script. These principles form the basis of all programming, not just within Godot.

In this section, we will cover the following topics:

Variables — storing and reusing data
Data Types — understanding different kinds of information
Constants — setting fixed, unchanging values
Functions — organizing your logic into reusable actions
Comments — explaining your code for yourself and others
Scope — understanding where and how your data exists

1. Variables

Variables are containers used to store reusable pieces of data such as numbers, text, or even entire nodes. You can think of them as your code’s “memory slots,” holding information like the player’s name, health, or the sound that plays when they take damage.

Variables can be defined globally, making them accessible in every piece of the script (and sometimes other scripts), or locally, within functions, where they exist only while that function runs.

Why Variables are Needed

Games constantly track information:

Player health, score, or ammo
Enemy positions
Whether a door is open or not
The name of the NPC you’re talking to

Without variables, a game wouldn’t know what happened before or what should happen next. It couldn’t reference or change values , making it impossible to keep track of states. Variables are the backbone of all programming.

Syntax

GDScript:

var variable_name = value
var player_health = 100

C#:

type variableName = value;
int playerHealth = 100

Best Practices

Use clear, descriptive names — for example, player_health or enemy_speed, so it’s easy to understand what each variable represents.
Follow snake_case naming in GDScript — write variable names in lowercase with underscores, like player_score or door_open.
Follow camelCase naming in C# — write variable names in camel case, like playerScore or doorOpen.
Avoid reserved keywords — don’t use words that Godot or GDScript already reserve for internal use (e.g. name, class, print), as this can cause errors or unexpected behavior.

Example

Here’s how you might define variables throughout your game.

The below code creates a player with the name “Bob”, who has 100 health and a sword.

GDScript:

var player_health = 100
var player_name = "Bob"
var has_sword = true

C#:

int playerHealth = 100;
string playerName = "Bob";
bool hasSword = true;

2. Data Types

Data types define the kind of information that a variable can store, such as numbers, text, boolean values (true/false), or even complex objects like nodes or images. They are essential for ensuring that your game can correctly utilize and process data while maintaining a standardized approach to handling and processing that data.

For example, by specifying the data type, we can prevent the addition of a string to a numeric data type. This means that you cannot assign “Bob” as a value for your health; it must always be a number or a float!

Why Data Types Are Needed

Every game needs to handle different kinds of information:

Numbers: Used for health, speed, or score. These can be either integers (whole numbers like 1 or 99) or floats (decimal values, such as 1.42 or 9.87).
Text: Refers to player names, dialogues, or menus. Text is defined as strings.
Boolean Values: Represent true/false states, such as “Is the door open?” or “Is the player jumping?”
Complex Types: Include structures like Vector2, Color, or Node, which are used for movement, visual representation, and object references.

Without data types, your game wouldn’t know how to compare, process, calculate, or display information properly. This could potentially lead to to confusing bugs and broken logic.

Types of Data

Syntax

GDScript:

var variable_name: Type = value
var player_speed: float = 4.5

C#:

Type variableName = value;
float playerSpeed = 4.5f;

Best Practices

Always use the correct type for what you’re storing — use integers (int) for whole numbers, floats (float) for decimals, and strings (String) for text.
Be consistent — don’t change a variable’s type mid-script (e.g., storing a number and later replacing it with text).
Use type hints (GDScript 2.0+) or explicit types (C#) to make your code safer and easier to read.
Learn Godot’s built-in types — like Vector2, Vector3, Color, Node, and Array, as they’re core to building any game.

Example

Here’s how you might define different data types for a player’s stats and position.

The below code creates a player with a name of “Bob” (value of string), a health of 100 and speed of 4.5 (numeric values), a sword (boolean), and position (Vector2).

GDScript:

var player_name: String = "Bob" #string
var player_health: int = 100 #integer
var player_speed: float = 4.5 #float
var has_sword: bool = true #boolean
var player_position: Vector2 = Vector2(200, 100) # complex type

C#:

string playerName = "Bob"; //string
int playerHealth = 100; //integer
float playerSpeed = 4.5f; //float
bool hasSword = true; //boolean
Vector2 playerPosition = new Vector2(200, 100); //complex type

3. Constants

Constants are values that never change while your game runs. They’re like permanent markers in your code — once defined, they stay the same no matter what happens.

You might use constants for things like maximum health, gravity, default speed, or level names. These are all values that should stay fixed and not be altered during gameplay.

Why Constants Are Needed

Constants make your code more organized, predictable, and easier to maintain.

They’re especially useful for:

Fixed values that should never change, like MAX_HEALTH = 100 (we want our health to change, but never go over 100%)
Game settings like gravity, jump force, or map size
Avoiding “magic numbers” — instead of random hard-coded numbers, you give them clear names
Preventing accidental changes to important values during gameplay

Without constants, you might end up reusing the same number in multiple places, and if you ever need to change it, you’ll have to hunt it down everywhere in your code.

Syntax

GDScript:

const CONSTANT_NAME = value
const MAX_HEALTH = 100

C#:

const Type CONSTANT_NAME = value;
const int MAX_HEALTH = 100;

Best Practices

Use constants for fixed or shared values — especially ones that appear multiple times in your code.
Name constants in ALL_CAPS to make them stand out (e.g., MAX_SPEED, GRAVITY).
Group related constants together at the top of your script for better organization.
Never modify a constant after it’s defined in your code. That defeats its purpose, so if you define it at the beginning of your code, avoid modifying its value later in a function.

Example

Here’s how you might define constants for player attributes and physics.

The code below creates constants that ensure the maximum health never surpasses 100%, sets a gravity force of 9.8, assigns the final player name as Bob, and establishes a spawn position that will never change.

GDScript:

const MAX_HEALTH = 100
const GRAVITY = 9.8
const PLAYER_NAME = "Bob"
const START_POSITION = Vector2(100, 200)

C#:

const int MAX_HEALTH = 100;
const float GRAVITY = 9.8f;
const string PLAYER_NAME = "Bob";
readonly Vector2 START_POSITION = new Vector2(100, 200);

4. Functions

Functions are reusable blocks of code that perform specific tasks. They let you organize your logic into smaller, manageable pieces, almost like instructions you can call at anytime.

Think of a function as a mini-program inside your script: instead of writing the same code over and over, you define it once and call it whenever needed.

Why Functions Are Needed

Games rely on repeated actions and logic. For example, an NPC should know when to walk and when to stop. Functions make that process clean and efficient.

For example:

Moving a character
Playing a sound when the player takes damage
Spawning an enemy or item
Saving or loading game data

Without functions, you’d need to duplicate the same lines of code in multiple places — making your game harder to read, debug, and maintain. Functions promote clean, modular, and reusable code.

Syntax

GDScript:

func function_name(parameters):
    # code to run
    return value

func add(a, b):
   return a + b

C#:

ReturnType FunctionName(parameters)
{
    // code to run
    return value;
}

int Add(int a, int b) { 
  return a + b; 
}

Best Practices

Use clear, action-based names (e.g., move_player(), take_damage(), play_music()), so it’s obvious what the function does.
Keep functions focused — each one should do one thing well.
Use parameters to pass data into a function, and returns to get data back.
Avoid long functions — break them into smaller pieces for readability and reuse.
In GDScript, function names use snake_case; in C#, use PascalCase.

Example

The code defines a variable which stores the player’s health, and in the function, whenever the player takes damage, the health value changes. Thus, the function controls the logic for when the player takes damage.

GDScript:

# variable
var player_health = 100

# function to change variable
func take_damage(amount):
    player_health -= amount
    print("Player health:", player_health)

C#:

// variable
int playerHealth = 100;

// function to change variable
void TakeDamage(int amount)
{
    playerHealth -= amount;
    GD.Print("Player health: " + playerHealth);
}

5. Comments

Comments are notes that you leave inside your code that the computer completely ignores. They’re meant for you and other developers to explain what your code does, why you wrote it that way, or to temporarily disable certain lines during testing.

Think of comments as sticky notes for your future self. They help make your code readable, teachable, and easier to maintain.

Why Comments Are Needed

As you grow your game, your code may become confusing after a few weeks (or to someone new reading it). Comments help you remember the reasoning behind your decisions, and take notes on what you need to change or refer back to.

You might use comments to:

Explain what a function or variable does
Clarify complex logic or math
Leave notes for future improvements
Temporarily disable code without deleting it

Without comments, your codebase can quickly become a maze of unexplained logic — especially in large projects with multiple scripts and systems.

Syntax

GDScript:

# GDScript
# Single-line comment
# This explains a line of code

C#:

// CSharp 
// Single-line comment
/* Multi-line
   comment */
// This explains a line of code

Best Practices

Write comments for clarity, not decoration. Use them to explain why something exists, not just what it does.
Keep comments up to date. Outdated comments can be more confusing than no comments at all.
Use comments to break your code into sections. It helps you navigate long scripts easily.
In GDScript, comments start with #.
In C#, comments start with //.

Example

Here’s how you might use comments to explain your code in both languages.

GDScript:

# Player starts with 100 health
var player_health = 100  

# Function to apply damage to the player
func take_damage(amount):
    player_health -= amount
    print("Player health:", player_health)  # Debug print to console

C#:

// Player starts with 100 health
int playerHealth = 100;

/* Function to apply damage
   and display remaining health */
void TakeDamage(int amount)
{
    playerHealth -= amount;
    GD.Print("Player health: " + playerHealth); // Debug print
}

6. Scope

Scope determines where a variable or function can be accessed in your code. It’s like defining whether a certain piece of logic is available everywhere or only inside a specific block of code.

Why Scope Is Needed

Scope keeps your code clean, predictable, and safe from unwanted changes.

In games, you might want some data to be accessible everywhere (like the player’s score), while other data should only exist temporarily inside a function (like a loop counter or a temporary position).

Without scope rules, variables could overwrite each other, cause bugs, or leak data across scripts unintentionally.

Here’s the most common scopes:

Global scope: Variables and functions that can be accessed from anywhere in the script, and sometimes by other scripts.
Local scope: Variables that only exist inside a specific function or block. They’re created when the function runs and destroyed when it ends.
Access modifiers (C# only): Define who can access a variable or function from other scripts.

Syntax

GDScript:

# Global variable
var global_var = value

func some_function():
    var local_var = value  # Local to this function - you cannot call it outside of here

C#:

// Global variable
int globalVar = 100;

void SomeFunction()
{
    int localVar = 50; // Only accessible inside this function
}
// Access modifiers (C# only)
public int localVar = 100;    // Accessible by all scripts
private int localVar = 30;       // Accessible only in this class
protected int localVar = 10;         // Accessible in this class and subclasses
internal int localVar = 0;           // Accessible within the same assembly

Best Practices

Use local scope whenever possible — it keeps variables self-contained and prevents accidental changes elsewhere.
Use global scope only for shared data like settings, player stats, or managers that must be accessed by multiple scripts.
Avoid naming conflicts — two variables with the same name in different scopes can cause confusion.
In GDScript, define globals outside of functions (like at the top of your script), and locals inside.
In C#, use access modifiers like public, private, and protected to control visibility.

Example

Here’s a simple example showing the difference between global and local scope.

GDScript:

# Global variable - any function can access this, even other scripts
var player_health = 100

func take_damage(amount):
    # Local variable (only exists while this function runs)
    var new_health = player_health - amount
    print("After damage:", new_health)

C#:

// Global variable - any function can access this, even other scripts
public int playerHealth = 100;    // Accessible by all scripts
private int ammoCount = 30;       // Accessible only in this class
protected int armor = 10;         // Accessible in this class and subclasses
internal int score = 0;           // Accessible within the same assembly

void TakeDamage(int amount)
{
    // Local variable (only exists within this function)
    int newHealth = playerHealth - amount;
    GD.Print("After damage: " + newHealth);
}

Part II: Logic & Control

Games and programs are filled with decisions — should the player take damage? Should the door open? Should the enemy chase or retreat?

Logic and control structures enable your game to think, react, and adapt to various situations. These tools instruct your code on what actions to take and when to take them. They serve as the brain behind your game’s behavior, controlling the flow of the game, responding to player input, and determining outcomes.

In this section, we will explore the following concepts:

If / Else: Making choices
Match (Switch): Handling multiple possibilities
Loops (For / While): Repeating actions efficiently
Break, Return, & Continue: Controlling loop & function behavior

1. If / Else

If / Else statements are the foundation of decision-making in programming. They let your game choose different paths depending on whether certain conditions are true or false.

You can think of them like branching roads — your game checks a condition, and depending on the result, it takes one route or another.

Why If / Else Is Needed

Every game relies on conditions, for example:

If the player’s health reaches zero → trigger game over
If the score is high enough → unlock a new level
If a key is collected → open a door
If the player presses jump → play jump animation

Without conditional logic, your game would run in a straight line with no reaction to what happens — no decisions, no consequences, and no interactivity.

Syntax

GDScript:

if condition:
    # code
elif other_condition:
    # code
else:
    # code

C#:

if (condition)
{
    // code
}
else if (otherCondition)
{
    // code
}
else
{
    // code
}

Best Practices

Keep conditions clear and readable — use descriptive variable names so your logic reads like a sentence (if player_health <= 0:).
Avoid deep nesting — too many nested if statements make code hard to follow. Consider using match or early returns instead.
Use elif for multiple related conditions instead of chaining separate ifs.
Test edge cases — ensure your logic works at boundaries (e.g., 0 health, max score).

Example

Here’s a simple block of code that uses if/else statements to determine whether the player is alive, low on health, or defeated.

GDScript:

var player_health = 50

# If health is more than zero, the player is alive.
if player_health > 50:
    print("Player is alive!")
# If health is between 1 and 50, warn that it's low.
elif player_health > 0 and player_health <= 50:
    print("Player health low")
# Otherwise, the player is defeated.
else:
    print("Player is defeated.")

C#:

int playerHealth = 50;

// If health is more than zero, the player is alive.
if (playerHealth > 50)
{
    GD.Print("Player is alive!");
}
// If health is between 1 and 50, warn that it's low.
else if (playerHealth > 0 && playerHealth <= 50)
{
    GD.Print("Player health low");
}
// Otherwise, the player is defeated.
else
{
    GD.Print("Player is defeated.");
}

2. Match (Switch)

The Match statement (called Switch in many other languages) is a cleaner, more organized way to handle multiple possible outcomes for a single value.

Instead of writing a long chain of if and elif statements, match lets your code check one variable against several conditions, thus keeping your logic simple and easy to read.

Think of it like a menu of possibilities: the program picks the one that matches and runs the code for that case.

Why Match Is Needed

When your game needs to react differently to multiple options — such as player input, item types, or enemy states — match keeps your logic tidy.

For example:

Checking which key was pressed
Determining what item the player picked up
Reacting to an enemy’s state (idle, chasing, attacking)
Handling dialog choices or menu selections

Without match, you’d end up with repetitive if/elif blocks that are harder to maintain.

Syntax

GDScript:

match value:
    pattern1:
        # code
    pattern2:
        # code
    _:
        # default case

C#:

switch (value)
{
    case pattern1:
        // code
        break;
    case pattern2:
        // code
        break;
    default:
        // default case
        break;
}

Best Practices

Use match for clear, single-variable comparisons — it’s cleaner than stacking if/elif.
Include a _ (default) case to catch unexpected values or errors.
Keep cases short and direct — avoid nesting too much logic inside each one.
In C#, use the switch statement (and consider switch expressions in newer C# versions for concise code).

Example

Here’s how you might use match to handle player actions. The logic of the game will change depending on the state of the player.

GDScript:

# Player state
var action = "jump"

# Change state based on action
match action:
    "attack":
        print("Player attacks!")
    "jump":
        print("Player jumps!")
    "block":
        print("Player blocks!")
    _:
        print("Unknown action!")

C#:

// Player state
string action = "jump";

// Change state based on action
switch (action)
{
    case "attack":
        GD.Print("Player attacks!");
        break;
    case "jump":
        GD.Print("Player jumps!");
        break;
    case "block":
        GD.Print("Player blocks!");
        break;
    default:
        GD.Print("Unknown action!");
        break;
}

3. Loops (For / While)

Loops allow your code to repeat actions automatically without writing the same line over and over. They’re essential for anything that needs to run multiple times — like moving enemies, checking objects, or counting through a list.

Think of loops as automated cycles: you define what should happen and how long it should continue

Why Loops Are Needed

Games rely on repetition — from drawing frames to checking collisions. Loops make that process simple and efficient.

You might use them to:

Move every enemy in a list
Spawn several coins or projectiles
Update player stats each frame
Repeat something until a condition is met

Without loops, you’d have to manually duplicate code for every instance — wasting time and creating room for errors.

Syntax

GDScript:

for element in collection:
    # repeated code

while condition:
    # repeated code

C#:

foreach (var element in collection)
{
    // repeated code
}
while (condition)
{
    // repeated code
}

Best Practices

Use for loops when you know how many times something should run (e.g., counting or iterating through arrays).
Use while loops when you don’t know how long something will continue (e.g., waiting for an event or condition).
Avoid infinite loops — always include a clear condition or break.
Use descriptive loop variables (for enemy in enemies: instead of for i in range(…)).
Keep loop bodies small — too much logic inside can hurt performance.

Example

Here’s how you might use both types of loops to manage enemies in a scene.

The for loop will iterate over a list of enemies (Goblin, Orc, and Troll), and for each enemy, it will print a message indicating that they are ready to attack.

The while loop will decrease the player’s health as long as their current health is more than 0. Once the player’s health reaches 0, the loop will stop.

GDScript:

# Array of enemies
var enemies = ["Goblin", "Orc", "Troll"]

# FOR LOOP: Go through a list of enemies
for enemy in enemies:
    print(enemy, "is ready to attack!")

# WHILE LOOP: Reduce player health over time
var player_health = 100
while player_health > 0:
    player_health -= 10
    print("Player health:", player_health)

C#:

// Array of enemies
string[] enemies = { "Goblin", "Orc", "Troll" };

// FOR LOOP: Go through a list of enemies
foreach (string enemy in enemies)
{
    GD.Print(enemy + " is ready to attack!");
}

// WHILE LOOP: Reduce player health over time
int playerHealth = 100;
while (playerHealth > 0)
{
    playerHealth -= 10;
    GD.Print("Player health: " + playerHealth);
}

4. Break, Continue, & Return

Inside loops and functions, break, continue, and return are special keywords that give you precise control over how and when your code stops or skips certain actions.

break — immediately stops a loop, even if it hasn’t finished all its cycles.
continue — skips the rest of the current loop cycle and jumps to the next one.
return — exits a function immediately and optionally sends a value back.

Think of them as traffic signs for your logic flow: “Stop here,” “Skip ahead,” or “Exit and report back.”

Why They’re Needed

Games constantly run logic loops and functions that depend on changing conditions. These keywords give you fine-grained control over when that logic should stop, skip, or exit.

You might use them to:

break when you’ve found the first matching item in a list
continue to skip inactive enemies or irrelevant data
return to exit a function early (like when the player is already dead)
Save performance by stopping unnecessary calculations

Without these control statements, loops and functions would run to completion every time — wasting cycles and cluttering logic.

Syntax

GDScript:

break       # Exit loop immediately
continue    # Skip to next loop iteration
return value  # Exit function and return value

C#:

break;       // Exit loop immediately
continue;    // Skip to next loop iteration
return value; // Exit function and return value

Best Practices

Use break only when needed to exit loops early.
Use continue for filtering logic, such as skipping invalid data.
Use return for early exits in functions, especially for edge-case checks.
Avoid multiple returns in long functions — too many can make code flow harder to follow.
Keep conditions clear and simple to prevent confusion when jumping out of loops or functions.

Example

Here’s how you might combine all three in a single gameplay function.

In the code below, we loop through our list of enemies. If we encounter an invalid enemy, we use the continue statement to skip to the next iteration. If we find an Orc in the list, we print a message and continue with the remaining logic (checking for dragon). If we come across a dragon, we print a message and exit the loop using the break statement. Once the loop is complete, we return, which stops the function from executing further.

GDScript:

func find_enemy(enemies):
    for enemy in enemies:
        if enemy == null:
            continue  # Skip missing entries
        if enemy == "Orc":
            print("Ignoring Orc.")
            continue # Skip missing entries
        if enemy == "Dragon":
            print("Boss found! Stopping search.")
            break # Stop loop
        print("Spotted:", enemy)
    return "Search complete."  # Exit function and return a message

C#:

string FindEnemy(string[] enemies)
{
    foreach (string enemy in enemies)
    {
        if (enemy == null)
            continue; // Skip missing entries
        if (enemy == "Orc")
        {
            GD.Print("Ignoring Orc.");
            continue; // Skip missing entries
        }
        if (enemy == "Dragon")
        {
            GD.Print("Boss found! Stopping search.");
            break; // Stop loop
        }
        GD.Print("Spotted: " + enemy);
    }
    return "Search complete."; // Exit function and return a message
}

Part III: Collections

As your games develop, you’ll soon realize that single variables, like player_name and enemy, aren’t sufficient. You will need ways to store, organize, and manage groups of data, such as multiple enemies, items, or lines of dialogue.

Collections are special data structures that enable you to handle many values simultaneously, making your scripts more dynamic, efficient, and powerful.

In this section, we’ll cover:

Arrays — ordered lists of values
Dictionaries — key-value pairs for labelled data
Resources — saved or reusable data objects

1. Arrays

Arrays are ordered lists that can store multiple values in a single variable.
You can think of them as containers or shelves, where each slot holds an item — like a list of enemies, levels, or collected items.

Each item in an array is stored at a numbered position called an index, starting at 0.

Why Arrays Are Needed

Arrays are essential whenever you need to handle more than one piece of related data.

For example:

A list of enemies in a level
All items in the player’s inventory
A sequence of checkpoints or spawn points
A queue of dialog lines or sound effects

Without arrays, you’d need a separate variable for every element (enemy1, enemy2, enemy3…), which quickly becomes unmanageable and performance heavy.

Syntax

GDScript:

var array_name = [value1, value2, value3]
array_name.append(value)
array_name[index]

C#:

Type[] arrayName = { value1, value2, value3 };
arrayName[index];
var listName = new List() { value1, value2, value3 };
listName.Add(value);

GDScript Methods

C# Methods

Best Practices

Use arrays for ordered data where position matters.
Access elements by index — array[0] gets the first item.
Use loops to efficiently process all items.
Be careful with indices — trying to access an index that doesn’t exist causes an error.
Use methods like append(), erase(), or size() to manage array contents.

Example

Here’s how you might use arrays to handle multiple enemies.

We start by defining an array named enemies, which holds a list of enemy names. Next, we print the first element in the array (at index 0), which is “Goblin”. After that, we add a new enemy “Dragon” to the list. When we print the array again, it will then display the updated list: [“Goblin”, “Orc”, “Troll”, “Dragon”]

GDScript:

var enemies = ["Goblin", "Orc", "Troll"]

# Access the first element
print(enemies[0])  # Output: Goblin
# Add a new enemy
enemies.append("Dragon")
# Loop through the list
for enemy in enemies:
    print(enemy)

C#:

// Create an array of enemies
string[] enemies = { "Goblin", "Orc", "Troll" };

// Access the first element
GD.Print(enemies[0]);  // Output: Goblin
// Convert to a dynamic list to add new items
var enemyList = new System.Collections.Generic.List(enemies);
enemyList.Add("Dragon");
// Loop through the list
foreach (string enemy in enemyList)
{
    GD.Print(enemy);
}

2. Dictionaries

Dictionaries store data as key–value pairs, allowing you to label each piece of information instead of relying on numerical positions.

Think of a dictionary as a filing cabinet — the key is the label on the drawer, and the value is what’s inside. This makes your data easier to understand and access, especially when order isn’t important but meaning is.

Why Dictionaries Are Needed

Dictionaries are perfect for data that needs names instead of numbers.

For example:

Storing player stats like {“health”: 100, “mana”: 50}
Tracking inventory items and their quantities
Keeping NPC dialog by character name
Mapping key bindings or configuration settings

Without dictionaries, you’d need separate variables or parallel arrays for every related value — which quickly gets messy.

Syntax

GDScript:

var dict_name = {
    "key1": value1,
    "key2": value2
}
dict_name["key3"] = value3

C#:

var dictName = new Dictionary()
{
    { "key1", value1 },
    { "key2", value2 }
};
dictName["key3"] = value3;

GDScript Methods

C# Methods

Best Practices

Use dictionaries when labels make data clearer — e.g., player["health"] is more readable than player[0].
Access values by key, not index — use dict["key_name"].
Check for existence before accessing a key to avoid errors (if “health” in player:).
Use nested dictionaries for structured data (like characters, stats, or items).
In C#, use Dictionary for type-safe collections.

Example

Here’s how you might use dictionaries to store player stats and inventory.

In the code below, we create a new dictionary for our players values — storing their name, health, and mana. We then add a new value to the dictionary, which will store the amount of gold that they have. Finally, we iterate over the dictionary to return the updated dictionary, which will be: {“name”: “Bob”, “health”: 100, “mana”: 50, “gold”: 250}

GDScript:

# Create a dictionary of player stats
var player = {
    "name": "Bob",
    "health": 100,
    "mana": 50
}

# Access a value by key
print(player["health"])  # Output: 100

# Add a new key-value pair
player["gold"] = 250

# Loop through keys and values
for key in player:
    print(key, ":", player[key])

C#:

using System.Collections.Generic;

// Create a dictionary of player stats
Dictionary player = new Dictionary()
{
    { "name", "Bob" },
    { "health", 100 },
    { "mana", 50 }
};

// Access a value by key
GD.Print(player["health"]);  // Output: 100

// Add a new key-value pair
player["gold"] = 250;

// Loop through all keys and values
foreach (var stat in player)
{
    GD.Print(stat.Key + ": " + stat.Value);
}

3. Resources

Resources in Godot are data objects that can be saved, loaded, and reused across your project. They’re stored as .tres (text-based) or .res (binary) files, and can contain variables, configurations, or even scripts — anything from item stats and materials to player data or configuration settings.

Think of them as data containers that live outside your scripts, allowing you to manage information in a clean, modular way.

Why Resources Are Needed

Resources make your game more modular, reusable, and data-driven. Instead of hardcoding every item and managing a list of arrays or dictionaries, you can store that information in Resource files and reuse them across multiple scenes or objects.

You’ll typically use Resources to:

Store item stats (like damage, rarity, or price).
Define enemy attributes or character abilities.
Create configuration files for tuning and game balance.
Create NPC, enemy, or character data which can be loaded into scenes.
Save and load player progress or inventory data.
Define materials, audio effects, shaders, and particle settings.

Without resources, you’d have to duplicate data across scripts or scenes, making your project harder to update, maintain, and balance.

Custom Resource Example

You can create your own resource classes to store structured data, such as an RPG item database or character stats.

GDScript

# ItemData.gd
extends Resource
@export var name: String
@export var damage: int
@export var price: int

Once you’ve created your custom Resource script (for example, ItemData.gd), you can easily create Resource files directly inside the Godot Editor — no code needed.

To create a Resource file:

In the FileSystem panel, right-click anywhere in your data/ folder (or wherever you want to store it).
Select New Resource → Create Resource.
In the window that appears, scroll down and select your custom class (e.g., ItemData).
Click Create, then assign your script (ItemData.gd) if it’s not already linked.
You’ll now see your custom exported variables (like name, damage, and price) in the Inspector.
Fill in their values — e.g. name = "Sword", damage = 10, price = 100.
Save it as sword.tres.

For example, you could create multiple item resources:

data/
  sword.tres
  axe.tres
  potion.tres

Then load them in-game:

var sword = load("res://data/sword.tres")
print(sword.name, "does", sword.damage, "damage")

C#

// ItemData.cs
using Godot;

[GlobalClass]
public partial class ItemData : Resource
{
    [Export] public string Name { get; set; }
    [Export] public int Damage { get; set; }
    [Export] public int Price { get; set; }
}

You can now create .tres resources from this script directly in the editor — each one representing an item.

Best Practices

Use .tres for text-based resources (readable and version control friendly).
Keep reusable data in res://data/ or a similar dedicated folder.
Use custom Resource scripts for structured data (like items, quests, or NPCs).
Don’t hardcode data — load and reference Resource files instead.
Reuse Resources between multiple nodes or scenes whenever possible.
Avoid circular references (when Resources reference each other in a loop).

Example

Here’s how you can create, load, and use Resources dynamically to power your game’s item system.

GDScript

# Game.gd
extends Node

func _ready():
    var sword = load("res://data/sword.tres")
    print("Picked up:", sword.name)
    print("Damage:", sword.damage)

C#

using Godot;

public partial class Game : Node
{
    public override void _Ready()
    {
        var sword = (ItemData)GD.Load("res://data/sword.tres");
        GD.Print($"Picked up: {sword.Name}");
        GD.Print($"Damage: {sword.Damage}");
    }
}

Part IV: Gameplay Mechanics

Now that you understand how to store data and control logic, it’s time to explore the coding features that can help make your game interactive. Gameplay mechanics are what bring your project to life by connecting player actions, objects, and events in real time. They’re what make doors open, characters jump, and music change when you take damage.

In this section, we’ll explore:

Signals (Events) — letting nodes communicate with each other
Input — handling player actions and controls
Timers — triggering delayed or repeated actions
Physics Process vs. Process — controlling frame updates and physics logic
Random Numbers — adding unpredictability and variety

1. Signals (Events)

Signals are Godot’s way of letting nodes communicate without being directly connected. Think of them as events, where one node or part of the code “emits” a signal, and another “listens” and reacts to it. This makes your game more modular and organized, since nodes don’t need to directly reference each other to interact.

You can use signals for all sorts of gameplay interactions:

Notify the game that the Start button was pressed → start the game
Have the UI flash red when the player takes damage
When an action is pressed, tell the door to open
When an animation is complete, switch to the next one

Signals turn isolated nodes into a living system that reacts to events in real time, which is a key concept for dynamic, responsive gameplay.

Why Signals Are Needed

Signals allow for clean, modular communication between game elements.

You’ll use them to:

Detect button presses in UI
React when a player’s health changes
Trigger events when a collision shape is entered or exited
Notify scripts when timers finish or animations end

Without signals, nodes would need to constantly “poll” each other, ultimately creating messy code.

Syntax

I like to think that signals are comprised of three main parts: Event → Listener → Response

GDScript:

# Emitting a signal (Event)
signal health_changed(new_health)
health_changed.emit_signal(80)

# Connecting a signal (Listener)
button.pressed.connect(_on_button_pressed)

# Defining the action (Response)
func _on_button_pressed():
    print("Button was pressed!")

C#:

// Emitting a signal (Event)
[Signal]
public delegate void HealthChangedEventHandler(int newHealth);
EmitSignal(nameof(HealthChanged), 80);

// Connecting a signal (Listener)
button.Pressed += OnButtonPressed;

// Response method (Response)
private void OnButtonPressed()
{
    GD.Print("Button was pressed!");
}

Best Practices

Use signals to decouple logic — nodes shouldn’t depend directly on each other
Connect signals in _ready() or in the editor for clarity.
Name custom signals descriptively, like player_died or door_opened.
Disconnect unused signals to prevent unexpected behavior.

Example

Here’s a simple setup where pressing a button updates the player’s health bar.

In the code below, we define a signal called health_changed in the Player script. When our player takes damage, we emit this signal to notify the other parts in our game that our health has changed.

When the signal is emitted, the other parts of our code which are connected to it, should execute their logic. In this case, we have another script called UI, which connects to this signal in the ready() function. We are connecting this signal to a new function in this script called on_health_changed. This tells the game our UI script is listening for events (emits) from the Player script, and whenever that event occurs, the logic within the function will execute - which in this case is a simple print statement notifying us of our new health value.

GDScript:

# Player.gd

# Signal creation
signal health_changed(new_health)
var health = 100

# Signal emission (Event)
func take_damage(amount):
    health -= amount
    health_changed.emit(health)

# UI.gd

# Signal connection (Listener)
func _ready():
    var player = get_node("../Player")
    player.health_changed.connect(_on_health_changed)

# Signal action (Response)
func _on_health_changed(new_health):
    print("Player health:", new_health)

C#:

// Player.cs

// Signal creation
[Signal]
public delegate void HealthChangedEventHandler(int newHealth);
int health = 100;

// Signal emission (Event)
public void TakeDamage(int amount)
{
    health -= amount;
    EmitSignal(nameof(HealthChanged), health);
}

// UI.cs

// Signal connection (Listener)
public override void _Ready()
{
    var player = GetNode("../Player");
    player.Connect("HealthChanged", this, nameof(OnHealthChanged));
}

// Signal action (Response)
private void OnHealthChanged(int newHealth)
{
    GD.Print("Player health: " + newHealth);
}

2. Input

Input is how players interact with your game. This can be via pressing keys, clicking, or touching the screen to control characters and trigger actions. Godot’s input system makes it easy to detect and respond to player actions through code or the Input Map (found in Project → Project Settings → Input Map).

You can think of Input as the player’s choices, and your game listens and reacts accordingly.

Why Input Is Needed

Every interactive game depends on Input:

Moving the player character
Jumping, attacking, or using abilities
Navigating menus or UI
Detecting gamepad or touchscreen actions

Without Input handling, your game wouldn’t know what the player wants to do, and the player won’t have any way of interacting with the game, they would just sit idle!

Syntax

GDScript:

# Detecting input actions continuously (we'll move right as long as we hold key)
func _process(delta):
    if Input.is_action_pressed("move_right"):
        # logic

# Detecting input actions once-off (we'll jump once and have to press key again)
func _input(event):
    if event.is_action_pressed("jump"):
        # logic

C#:

// Detecting input actions continuously (we'll move right as long as we hold key)
public override void _Process(double delta)
{
    if (Input.IsActionPressed("move_right"))
       // logic
}

// Detecting input actions once-off (we'll jump once and have to press key again)
public override void _Input(InputEvent @event)
{
    if (@event.IsActionPressed("jump"))
        // logic
}

Input Methods

Best Practices

Use the Input Map instead of hardcoding keys — this lets players rebind controls easily.
Check for actions (like "ui_accept" or "move_left") rather than specific keys.
Use _process() for continuous input (movement), and _input() for one-time actions (button presses).
Support multiple devices (keyboard, controller, touchscreen) whenever possible.
Keep input logic separate from gameplay logic — use signals or dedicated functions to handle actions cleanly.

Example

Here’s a simple movement script that lets a player move left and right, and jump when the spacebar is pressed.

In the code below, the move_right and move_left keys have been assigned to the ← → keys in the Project Settings, and the jump key to the spacebar.

GDScript:

extpends CharacterBody2D

const SPEED = 200
const JUMP_FORCE = -400

func _physics_process(delta):
    var velocity = Vector2.ZERO

    # Move player left and right
    if Input.is_action_pressed("move_right"):
        velocity.x += SPEED
    elif Input.is_action_pressed("move_left"):
        velocity.x -= SPEED

    # Move player up (jump)
    if is_on_floor() and Input.is_action_just_pressed("jump"):
        velocity.y = JUMP_FORCE
    velocity = move_and_slide(velocity, Vector2.UP)

C#:

using Godot;

public partial class Player : CharacterBody2D
{
    const float Speed = 200f;
    const float JumpForce = -400f;
    public override void _PhysicsProcess(double delta)
    {
        Vector2 velocity = Velocity;

        // Move player left and right
        if (Input.IsActionPressed("move_right"))
            velocity.X = Speed;
        else if (Input.IsActionPressed("move_left"))
            velocity.X = -Speed;
        else
            velocity.X = 0;

        // Move player up (jump) 
        if (IsOnFloor() && Input.IsActionJustPressed("jump"))
            velocity.Y = JumpForce;
        Velocity = velocity;
        MoveAndSlide();
    }
}

3. Timers

Timers are nodes that let you run code after a delay or repeatedly at fixed intervals. They’re essential for creating time-based events such as cooldowns, countdowns, enemy spawns, or temporary effects.

Think of a timer as an alarm clock inside your game: you set it, wait, and when it rings, something happens.

Why Timers Are Needed

Games constantly rely on timing to feel dynamic and balanced:

Countdown before starting a match
Enemy attack intervals
Power-up durations or cooldowns
Auto-saving or periodic events

Without timers, you’d need to manually track time using variables, which quickly becomes messy and unreliable.

Syntax

GDScript:

# Creating and starting a timer
var timer = Timer.new()
add_child(timer)
timer.wait_time = 2.0 # how long it will execute for (2 seconds)
timer.one_shot = true # will execute once, set to false for continuous execution
timer.start() # start the timer

# Connecting timeout signal
timer.timeout.connect(_on_timer_timeout)

# When timer times out, do this logic
func _on_timer_timeout():
    print("Time's up!")

C#:

// Creating and starting a timer
var timer = new Timer();
AddChild(timer);
timer.WaitTime = 2.0f; // how long it will execute for (2 seconds)
timer.OneShot = true; // will execute once, set to false for continuous execution
timer.Start(); // start the timer
timer.Timeout += OnTimerTimeout; 

// When timer times out, do this logic
private void OnTimerTimeout()
{
    GD.Print("Time's up!");
}

Best Practices

Use Timer nodes for clarity instead of manually counting seconds in _process().
Connect the timeout signal to trigger actions cleanly when the timer finishes.
Set one_shot to true for single-use timers, or false to make them loop.
Use start() and stop() to control timers in code.
Reuse timers for repeating events rather than creating new ones each time.

Example

Here’s how you might use a Timer to respawn an enemy 3 seconds after it’s defeated.

In the code below, we create a timer as soon as our game starts. When it’s created, we also connect its timeout signal to our script (this can be done in the editor itself, instead of via code). When the enemy is defeated, say their health reaches below zero, we start the timer. The timer will run for however long we’ve set its wait_time, which is 3 seconds. When 3 seconds have passed, the timer will timeout, and the enemy will be respawned.

If the enemy dies again, the logic will start over again, unless we’ve set our timer to be one_shot enabled.

GDScript:

extends Node2D

# Create timer
func _ready():
    var respawn_timer = $RespawnTimer
    respawn_timer.wait_time = 3.0 
    respawn_timer.one_shot = false
    respawn_timer.timeout.connect(_on_respawn_timer_timeout)

# Start timer
func on_enemy_defeated():
    print("Enemy defeated! Respawning in 3 seconds...")
    $RespawnTimer.start()

# Stop timer
func _on_respawn_timer_timeout():
    print("Enemy has respawned!")

C#:

using Godot;

public partial class EnemySpawner : Node2D
{
    // Create timer
    private Timer RespawnTimer;
    public override void _Ready()
    {
        RespawnTimer = GetNode("RespawnTimer");
        RespawnTimer.WaitTime = 3b.0f; 
        RespawnTimer.OneShot = false;    
        RespawnTimer.Timeout += OnRespawnTimerTimeout;
    }
    // Start timer
    public void OnEnemyDefeated()
    {
        GD.Print("Enemy defeated! Respawning in 3 seconds...");
        RespawnTimer.Start();
    }
    // Stop timer
    private void OnRespawnTimerTimeout()
    {
        GD.Print("Enemy has respawned!");
    }
}

4. Physics Process vs. Process

In Godot, both _process() and _physics_process() are special built-in functions that run every frame — but they serve different purposes.

_process(delta) runs every rendered frame — perfect for animations, UI, and non-physics logic.
_physics_process(delta) runs at a fixed time step — perfect for movement, collisions, and anything that interacts with the physics engine.

Why It Matters

Games depend on predictable, consistent updates.

You’ll typically use:

_process() → for animations, timers, and UI transitions.
_physics_process() → for movement, gravity, and collisions.

Syntax

GDScript:

# Called every frame (variable time step)
func _process(delta):
    # do framerate related logic

# Called at a fixed time step (default: 60 times per second)
func _physics_process(delta):
    # do physics related logic
    # usually ends in move_and_slide() or move_and_collide()

C#:

// Called every frame
public override void _Process(double delta)
{
   // do framerate related logic
}

// Called at a fixed physics tick rate
public override void _PhysicsProcess(double delta)
{
    // do physics related logic
    // usually ends in MoveAndSlide() or MoveAndCollide()
}

Best Practices

Use _physics_process() for movement and collisions.
Use _process() for visual effects and non-physics updates.
Always multiply by delta to keep movement frame-rate independent.
Don’t mix physics logic in _process() — it can cause jitter or inconsistencies.
Pause logic carefully — timers and physics might still run if not managed properly.

Example

Here’s a basic player script that plays a characters run animations continuously whilst the input keys are being held down in the process() function. It also then moves the character around whilst the input keys are being held down in the physics_process() function.

GDScript:

# This will play the run animations on inputs
func _process(delta):
    if Input.is_action_pressed("move_right") or Input.is_action_pressed("move_left"):
        $AnimatedSprite2D.play("run")
    else:
        $AnimatedSprite2D.play("idle")

# This will move the player on inputs.
func _physics_process(delta):
    var velocity = Vector2.ZERO
    if Input.is_action_pressed("move_right"):
        velocity.x += 200
    elif Input.is_action_pressed("move_left"):
        velocity.x -= 200
    velocity = move_and_slide(velocity)

C#:

using Godot;

public partial class Player : CharacterBody2D
{
    const float Speed = 200f;
    private AnimatedSprite2D sprite;
    public override void _Ready()
    {
        sprite = GetNode("AnimatedSprite2D");
    }

    // This will play the run animations on inputs
    public override void _Process(double delta)
    {
        if (Input.IsActionPressed("move_right") || Input.IsActionPressed("move_left"))
            sprite.Play("run");
        else
            sprite.Play("idle");
    }

    //  This will move the player on inputs.
    public override void _PhysicsProcess(double delta)
    {
        Vector2 velocity = Vector2.Zero;
        if (Input.IsActionPressed("move_right"))
            velocity.X += Speed;
        else if (Input.IsActionPressed("move_left"))
            velocity.X -= Speed;
        Velocity = velocity;
        MoveAndSlide();
    }
}

5. Random Numbers

Random numbers add variety and unpredictability to your game, thus ensuring no two playthroughs feel exactly the same. Godot’s random system lets you generate numbers, select random items from arrays, or even produce random directions for projectiles or enemies.

Randomness makes things feel dynamic, alive, and surprising.

Why Random Numbers Are Needed

Games rely on randomness for endless replayability:

Loot drops or item rewards
Random enemy spawns
Critical hits or damage variation
Procedural generation (maps, terrain, puzzles)
Particle spread or visual effects

Without randomness, your game would feel repetitive and predictable.

Syntax

GDScript:

# Initialize random seed (usually in _ready)
randomize()

# Generate a random float between 0 and 1
var r = randf()

# Generate an integer between 0 and 10
var i = randi_range(0, 10)

# Pick a random element from an array
var enemies = ["Goblin", "Orc", "Troll"]
var random_enemy = enemies.pick_random()

# Random vector direction
var dir = Vector2(randf_range(-1, 1), randf_range(-1, 1)).normalized()

C#:

using Godot;
using System;

public partial class RandomExample : Node
{
    private Random rand = new Random();
    public override void _Ready()
    {
        // Random float between 0 and 1
        float r = (float)rand.NextDouble();

        // Random integer between 0 and 10
        int i = rand.Next(0, 11);

        // Random element from an array
        string[] enemies = { "Goblin", "Orc", "Troll" };
        string randomEnemy = enemies[rand.Next(enemies.Length)];

        // Random direction
        Vector2 dir = new Vector2(
            (float)rand.NextDouble() * 2 - 1,
            (float)rand.NextDouble() * 2 - 1
        ).Normalized();
        GD.Print($"Enemy: {randomEnemy}, Direction: {dir}");
    }
}

Best Practices

Use randomize() once at startup (in _ready()) to avoid repeating patterns.
Choose the right random function — Godot offers several for different data types.
Use seeded randomness for predictable results (great for replays or testing).
Clamp or round values if you only need whole numbers or limits.
Keep randomness balanced — too much can frustrate players.

Example

Here’s how you might use randomness to spawn enemies at random positions on the map.

GDScript:

extends Node2D

func _ready():
    randomize()
    for i in range(5):
        var enemy_scene = preload("res://Enemy.tscn").instantiate()
        enemy_scene.position = Vector2(
            randi_range(100, 800),
            randi_range(100, 400)
        )
        add_child(enemy_scene)

C#:

using Godot;
using System;

public partial class Spawner : Node2D
{
    private Random rand = new Random();
    public override void _Ready()
    {
        for (int i = 0; i < 5; i++)
        {
            var enemyScene = GD.Load("res://Enemy.tscn").Instantiate();
            enemyScene.Position = new Vector2(
                rand.Next(100, 801),
                rand.Next(100, 401)
            );
            AddChild(enemyScene);
        }
    }
}

6. The Ready Function

In Godot, the _ready() function is called once when a node enters the scene tree and is fully initialized. It’s the go-to place for setup logic such as loading resources, connecting signals, setting initial values, or caching references to other nodes.

Why Its Needed

When a node is created, not all of its children or dependencies exist yet. If you try to reference them too early, your code can break.

_ready() ensures the entire node hierarchy is loaded before running your setup code.

You’ll typically use it to:

Get references to child nodes
Connect signals between nodes
Load textures, sounds, or scenes
Initialize variables or game states

Without _ready(), you’d risk calling nodes or data that don’t exist yet.

Syntax

GDScript:

# Called once when the node enters the scene tree
func _ready():
    # Set values to be initialized
    var sprite = $Sprite2D
    var player_health = 100

C#:

using Godot;

public partial class Player : Node2D
{
    public override void _Ready()
    {
        // Set values to be initialized
        Sprite2D sprite = GetNode("Sprite2D");
        int playerHealth = 100
    }
}

Best Practices

Use _ready() for one-time setup only — not for logic that runs continuously.
Keep it clean and short — just initialization, no heavy loops or updates.
Access child nodes here safely — all children are guaranteed to exist.
Connect signals or timers in _ready(), not in _process().
Avoid creating dependencies between unrelated nodes — keep setups modular.

Example

Here’s a simple player setup that uses _ready() to load assets, connect signals, and initialize variables before gameplay starts.

GDScript:

extends CharacterBody2D

var health = 100

func _ready():
    $AnimatedSprite2D.play("idle")
    $HealthBar.max_value = health
    $Area2D.body_entered.connect(_on_body_entered)

func _on_body_entered(body):
    print("Collided with:", body.name)

C#:

using Godot;

public partial class Player : CharacterBody2D
{
    private int health = 100;
    private AnimatedSprite2D sprite;
    private ProgressBar healthBar;
    private Area2D hitArea;

    public override void _Ready()
    {
        sprite = GetNode("AnimatedSprite2D");
        sprite.Play("idle");
        healthBar.MaxValue = health;
        hitArea.BodyEntered += OnBodyEntered;
    }

    private void OnBodyEntered(Node body)
    {
        GD.Print($"Collided with: {body.Name}");
    }
}

Part V: Scenes & Nodes

In Godot, everything is a node. From your player and camera to UI buttons, lights, and audio — every piece of your game inherits from the Node class.

Nodes are the building blocks of Godot. When you combine them, you create scenes, which are self-contained groups of nodes that can represent anything: a level, a character, or even a menu. Together, these form the Scene Tree, a hierarchy that defines how everything in your game is organized, updated, and connected.

In this section, we’ll cover:

Node Basics — understanding what nodes are and how they work
Scenes — reusable groups of nodes that form your game’s structure
Inheritance — allows one scene or script to reuse another’s logic and structure.
Export variables — makes a variable visible and editable in the Inspector panel.
Groups — tagging nodes into similar categories

1. Accessing Nodes

A Node is the most fundamental building block in Godot. Each node has a name, a type, and optional children. Nodes within a scene creates a tree-like structure that defines how your game world is built.

Think of it like this:

Nodes are the building blocks.
Scenes are the containers which hold and organize nodes.

For a more visual reference on all the nodes and their use-cases, refer to my Book of Nodes.

View the online version of the above depiction of scenes and nodes here.

Why Nodes Are Needed

Without nodes, there would be no game. They’re the foundation of everything you create in Godot.

Nodes can represent almost anything:

A collider that detects hits
A sprite that displays a texture
A camera that follows the player
A light that illuminates the scene
A script that controls behavior

Without nodes, every part of your game would have to be hard-coded, messy, unorganized, and nearly impossible to maintain.

Syntax

Nodes are usually added within the editor itself, but we can create and reference nodes directly within our code.

GDScript:

# Referencing an existing node and changing its property 
var sprite = $Sprite2D
sprite.modulate = Color.RED

# Getting a node by path
var camera = get_node("Camera2D")

# Creating a new node
var new_label = Label.new()
new_label.text = "Hello World"
add_child(new_label)

C#:

// Referencing an existing node and changing its property 
Sprite2D sprite = GetNode("Sprite2D");
sprite.Modulate = new Color(1, 0, 0);

// Getting a node by path
Camera2D camera = GetNode("Camera2D");

// Creating a new node
Label newLabel = new Label();
newLabel.Text = "Hello World";
AddChild(newLabel);

Best Practices

Name nodes clearly (e.g., PlayerSprite, Hitbox, MainCamera).
Use composition — build functionality by combining nodes, not writing giant scripts.
Leverage node types — use the right node for the job (Area2D for detection, Sprite2D for visuals, etc.).
Keep the tree organized — indentation and naming go a long way.
Don’t overload one scene — break your game into multiple smaller, reusable ones.

Example

Here’s how you can reference a node that already exists and create a new one dynamically in the same script.

In the code below, we assume that within the editor we’ve added a Sprite2D node called “Sprite2D”. We reference this node in our script, and then we change its texture (sprite). We also create a new Label node with the text “Player ready”, and position it to our screen. The add_child() method adds the newly created node to our scene via the script.

GDScript:

extends Node2D

func _ready():
    # Reference an existing Sprite node
    var sprite = $Sprite2D
    sprite.texture = preload("res://sprites/player.png")

    # Create and add a new Label node
    var label = Label.new()
    label.text = "Player ready!"
    label.position = Vector2(10, 10)
    add_child(label)

C#:

using Godot;

public partial class Player : Node2D
{
    public override void _Ready()
    {
        // Reference an existing node
        Sprite2D sprite = GetNode("Sprite2D");
        sprite.Texture = (Texture2D)GD.Load("res://sprites/player.png");

        // Create and add a new node dynamically
        Label label = new Label();
        label.Text = "Player ready!";
        label.Position = new Vector2(10, 10);
        AddChild(label);
    }
}

2. Accessing Scenes

A Scene in Godot is a collection of nodes. It can represent this such as a character, a level, a user interface, or even a single reusable object.

Every scene has a root node, and that root defines the scene’s type. For example, a CharacterBody2D might be the root for a player scene, or a Control node might be the root for a UI screen.

Think of scenes as blueprints: you build them once in the editor, then reuse, instance, or switch between them dynamically during gameplay.

View the online version of the above depiction of scenes and nodes here.

Why Scenes Are Needed

Scenes make your game modular and reusable. They allow you to:

Build individual pieces of your game separately.
Reuse the same object (like enemies or items) multiple times.
Load and unload levels dynamically.
Transition between menus, gameplay, and cutscenes.

Without scenes, your entire game would live in one massive, unmanageable hierarchy, which makes updates, debugging, and testing a nightmare.

Syntax

GDScript:

# Load a scene from file
var enemy_scene = preload("res://scenes/Enemy.tscn")

# Create an instance of that scene
var enemy_instance = enemy_scene.instantiate()

# Add it to the current scene tree
add_child(enemy_instance)

# Change to another scene file
get_tree().change_scene_to_file("res://scenes/Level2.tscn")

# Reload the current scene
get_tree().reload_current_scene()

# Get a node from another scene (if it's loaded)
var player = get_tree().get_root().get_node("World/Player")
player.health = 50

C#:

// Load a scene from file
PackedScene enemyScene = (PackedScene)GD.Load("res://scenes/Enemy.tscn");

// Create an instance of that scene
Node enemyInstance = enemyScene.Instantiate();

// Add it to the current scene tree
AddChild(enemyInstance);

// Change to another scene file
GetTree().ChangeSceneToFile("res://scenes/Level2.tscn");

// Reload the current scene
GetTree().ReloadCurrentScene();

// Get a node from another scene (if it's loaded)
Node player = GetTree().Root.GetNode("World/Player");
player.Set("health", 50);

Best Practices

Keep scenes focused — each should represent one clear purpose (e.g., Player, MainMenu, Enemy, Level1).
Use the root node type wisely — it defines what the scene is and how it behaves.
Instance scenes instead of duplicating — this makes updates propagate automatically.
Use get_tree().change_scene_to_file() for transitions, and preload() or load() for instancing.
Keep references clean — don’t rely on global paths unless necessary.

Example

The below code loads and spawns an enemy scene when the player presses a key, and transitions to a new scene when health reaches zero.

GDScript:

extends Node2D

# Load scene
var enemy_scene = preload("res://scenes/Enemy.tscn")
var health = 100

func _process(delta):
    # Spawn enemy when pressing "E"
    if Input.is_action_just_pressed("spawn_enemy"):
        var enemy = enemy_scene.instantiate() # Spawn scene
        enemy.position = Vector2(400, 200)
        add_child(enemy)

    # Change to game over scene when health reaches zero
    if health <= 0:
        get_tree().change_scene_to_file("res://scenes/GameOver.tscn") # Transition scene

C#:

using Godot;

public partial class Level : Node2D
{
    // Load scene
    private PackedScene enemyScene = (PackedScene)GD.Load("res://scenes/Enemy.tscn");
    private int health = 100;

    public override void _Process(double delta)
    {
        if (Input.IsActionJustPressed("spawn_enemy"))
        {
            Node2D enemy = enemyScene.Instantiate(); // Spawn scene
            enemy.Position = new Vector2(400, 200);
            AddChild(enemy);
        }
        if (health <= 0)
            GetTree().ChangeSceneToFile("res://scenes/GameOver.tscn"); // Transition scene
    }
}

3. Inheritance

Inheritance allows you to create new scenes or scripts that reuse and extend the functionality of existing ones. It’s one of the most powerful features of coding, as it lets you define a base behavior (like a generic “Enemy”) and then build specialized versions (like “Goblin” or “Orc”) without rewriting everything from scratch.

There are two main types of inheritance in Godot:

Script inheritance — extending another script’s code using the extends keyword.
Scene inheritance — creating new scenes that build on existing ones in the editor.

Why Inheritance Is Needed

Inheritance helps you write cleaner, reusable, and modular code. It keeps your project organized and avoids duplication when many objects share similar traits.

For example:

A base Enemy scene might define health and damage logic for all enemies.
Derived scenes like Orc, Goblin, or Troll can inherit that and add their own unique animations or stats.
A CharacterBody2D script might define general movement for all characters in your game, and the Player script can extend it to handle input.

Without inheritance, you’d have to duplicate large chunks of code or rebuild scenes from scratch every time.

Best Practices

Use inheritance for shared functionality, not for one-off behaviors.
Keep base classes simple and focused — they should define core rules, not everything.
Override functions responsibly — always call super() or ._process(delta) if you still want the parent’s logic to run.
For scenes, use “Inherit Scene” in the editor instead of duplicating.
Use composition (adding child nodes) alongside inheritance for flexibility.

Syntax

Script Inheritance

GDScript:

# Base script: Base.gd
# The base class defines the basic values of your enemies
class_name Base
extends Node

var health = 100

func take_damage(amount):
    health -= amount
    print("Enemy took", amount, "damage. Health:", health)

# Derived script: Derived.gd
# The derived class gets everythign from the Base, such as health and take_damage() function
extends Base

func _ready():
    print("Goblin ready!")
    take_damage()

C#:

// Base script: Base.cs
// The base class defines the basic values of your enemies
using Godot;

public partial class Base : Node
{
    public int Health = 100;
    public virtual void TakeDamage(int amount)
    {
        Health -= amount;
        GD.Print($"Enemy took {amount} damage. Health: {Health}");
    }
}

// Derived script: Derived.cs
// The derived class gets everythign from the Base, such as health and take_damage() function
using Godot;

public partial class Derived : Base
{
    public override void _Ready()
    {
        GD.Print("Goblin ready!");
        base.TakeDamage(amount);
    }
}

Scene Inheritance

You can also inherit scenes directly in the editor:

Right-click an existing scene (e.g., Enemy.tscn).
Choose “New Inherited Scene”.
Godot creates a new version with all the parent nodes — ready for customization.

You can then:

Add new child nodes (e.g., a weapon or animation).
Override properties (like textures, speeds, or collision shapes).
Change script references while keeping base functionality intact.

Example

The code below creates a base Enemy class, which defines the shared behavior for all of our enemies. We then create two derived classes (Orc and Troll) which extends from it. These classes will get all the base functionality, such as health and take_damage(), but will still be able to get their own unique features.

This means our damage logic is the same for all enemies, but different enemies can have different animations, sound, and behavior.

GDScript:

# Base Enemy.gd
class_name Enemy
extends CharacterBody2D

var health = 100

func _ready():
    print("Enemy spawned with", health, "HP")

func take_damage(amount):
    health -= amount
    print("Enemy took damage:", amount)

# Orc.gd (inherits Enemy.gd)
# Orc plays a dance anim on taking damage, whilst still losing health
extends Enemy

func _ready():
    print("Orc enters the battlefield!")

func take_damage(amount):
    print("Orc roars in anger!")
    $animated_sprite.play("dance_anim")

# Troll.gd (inherits Enemy.gd)
extends "res://scripts/Enemy.gd"

func take_damage(amount):
    print("Troll regenerates some health!")
    health += 5

4. Export Variables

Export variables let you expose script properties directly to the Godot Editor. They make your scripts customizable, flexible, and designer-friendly, allowing you to change values without modifying the code.

Think of them as editable parameters which appear in the Inspector just like any built-in node property.

Why Export Variables Are Needed

Export variables bridge the gap between code and design. Instead of opening scripts to adjust things like player speed or enemy health for testing, you can edit them visually in the editor.

You’ll typically use them for:

Character attributes (health, speed, jump power)
Enemy AI settings (vision range, attack delay)
Visual tuning (colors, scale, offsets)
Audio or effect configuration
Linking external resources (textures, scenes, sounds)

Without exports, tuning gameplay would mean constant code edits and reloads, which slows development dramatically.

Syntax

GDScript:

# A variable visible and editable in the editor
@export var speed = 200
@export var player_name = "Hero"
# Choose a texture in the editor
@export var icon: Texture2D

C#:

[Export]
public float Speed = 200f;
[Export]
public string PlayerName = "Hero";
[Export]
public Texture2D Icon;

Best Practices

Use clear names — make sure exports describe what they control.
Set sensible defaults — keep values playable right away.
Add type hints (int, float, Color, PackedScene) for editor validation.
Use ranges and enums to restrict inputs and avoid mistakes.
Keep export usage simple — avoid exporting everything just for convenience.

Example

The below script exports variables which will be exposed to the Inspector panel for editing. This means whatever value we assign in the inspector panel will be the value assigned to that script — meaning it will overwrite hard-coded values in our script!

GDScript:

extends CharacterBody2D

@export var speed: float = 200.0
@export var jump_force: float = 400.0
@export var sprite_texture: Texture2D

C#:

using Godot;

public partial class Player : CharacterBody2D
{
    [Export] public float Speed = 200f;
    [Export] public float JumpForce = 400f;
    [Export] public Texture2D SpriteTexture;
}

4. Groups

Groups are a powerful way to organize and manage multiple nodes in Godot. They let you categorize nodes under a shared label (like “Enemies” or “Interactables”) so you can call functions, apply effects, or send signals to all of them at once.

Think of groups as tags for nodes. You can assign one or more groups to a node and then access them from anywhere in your game.

Why Groups Are Needed

Groups are essential when you have multiple instances of similar objects, like enemies, NPCs, or projectiles.

You’ll typically use them to:

Apply damage or effects to every enemy.
Check interactions dynamically — for example, showing an “Interact” prompt when focusing on an interactable group item, or triggering dialog when focusing on an NPC.
Enable or disable all interactables at once (e.g., pausing player input or freezing AI).
Trigger multiple lights, doors, or sounds with a single command.
Broadcast global events, like GameOver, LevelCleared, or Pause

Without groups, you’d need to manually loop through every node or keep separate arrays, which is messy, slow, and error-prone.

Syntax

You can assign nodes directly to Groups within the editor, but below is how you can add objects to groups using code.

GDScript:

# Add the node to a group
add_to_group("Enemies")

# Check if the node belongs to a group
if is_in_group("Enemies"):
    print("This node is an enemy!")

# Remove the node from a group
remove_from_group("Enemies")

C#:

// Add the node to a group
AddToGroup("Enemies");

// Check if the node belongs to a group
if (IsInGroup("Enemies"))
    GD.Print("This node is an enemy!");

// Remove the node from a group
RemoveFromGroup("Enemies");

Best Practices

Use groups to organize related nodes (e.g., “Enemies”, “Collectibles”, “UI”).
Add groups via code or the editor (under the “Node → Groups” tab).
Avoid too many overlapping groups — keep naming meaningful.
Use is_in_group() to check membership before applying logic.
Leverage signals and call_group() for clean global communication.

Example

Here’s how you can use groups to detect whether the player is focusing on an interactable object (like an item, door, or NPC). If the object is in the Interactable group, the player receives a message prompt.

GDScript:

# Player.gd
extends CharacterBody2D

func _process(delta):
    # Cast a ray forward to detect what the player is looking at
    var space_state = get_world_2d().direct_space_state
    var result = space_state.intersect_ray(global_position, global_position + Vector2(50, 0))
    
    # Get the collider of the object
    if result and result.has("collider"):
        var target = result.collider

        # If its in interactable group, show prompt
        if target.is_in_group("Interactable"):
            print("You're focusing on an interactable. Press [E] to pick up.")
        else:
            print("You're looking at:", target.name)

C#:

// Player.cs
using Godot;

public partial class Player : CharacterBody2D
{
    public override void _Process(double delta)
    {
        // Cast a ray forward to detect what the player is looking at
        var spaceState = GetWorld2D().DirectSpaceState;
        var result = spaceState.IntersectRay(GlobalPosition, GlobalPosition + new Vector2(50, 0));
    
        // Get the collider of the object
        if (result.Count > 0 && result.ContainsKey("collider"))
        {
            var target = result["collider"] as Node;

            // If its in interactable group, show prompt
            if (target.IsInGroup("Interactable"))
                GD.Print("You're focusing on an interactable. Press [E] to pick up.");
            else
                GD.Print($"You're looking at: {target.Name}");
        }
    }
}

Part VI: Bonus

You’ve learned how to build the core gameplay systems of a Godot project. Now it’s time to focus on the finishing touches that make your project clean, stable, and scalable.

This section covers the tools and habits that keep your code readable, debuggable, and organized — especially as your project grows.

We’ll go over:

Code Style Tips — write clear, consistent, and maintainable code.
Debugging — identify and fix issues effectively.
Autoloads (Singletons) — manage global data and cross-scene communication.

1. Code Style Tips

Clean code isn’t just about getting things to work, it’s about making your future self thank you later.
Readable scripts are easier to debug, share, and extend.

Why It Matters

As projects grow, consistency becomes critical. Having clear naming, structure, and commenting habits keeps your code easy to understand for everyone (including you, months later).

Best Practices

Use consistent naming:
GDScript → snake_case for variables and functions.
C# → camelCase for variables and PascalCase for methods and classes.
Comment with purpose: Explain why, not just what.
Group related code: Keep setup, logic, and cleanup organized in sections OR code regions.
Avoid magic numbers: Use constants or exported variables instead.
Keep functions short: Each function should do one clear thing.
Be descriptive: player_health is better than hp1.

Example (GDScript)

# Bad
var s = 10
func x():
    s -= 1
    if s == 0: print("Dead")

func phello():
    print("Hello")

# Good
#region [Player Health Management]
var player_health = 10

func take_damage(amount):
    player_health -= amount
    if player_health <= 0:
        print("Player defeated")
        # Trigger game over sequence
#endregion

#region [Debugging]
func print_hello():
    print("Hello")
#endregion

2. Debugging

Every developer runs into bugs, it’s just inevitable. The key is finding and understanding them quickly. Godot provides a range of built-in tools to help you diagnose problems effectively.

Best Practices

Use print() or GD.Print() to log key values and track execution flow.
Use assert(condition) to catch unexpected states early.
Use the Debugger panel (bottom dock) to pause on errors and inspect variables.
Leverage breakpoints to step through your code line by line.
Enable “Visible Collision Shapes” in the Debug menu to check collisions.
Don’t ignore warnings — they often point to subtle bugs before they crash your game.

Example

GDScript:

func _physics_process(delta):
    assert(player != null, "Player reference missing!")
    if player.health <= 0:
        print("Player is dead")

C#:

public override void _PhysicsProcess(double delta)
{
    GD.Assert(Player != null, "Player reference missing!");
    if (Player.Health <= 0)
        GD.Print("Player is dead");
}

3. Using Autoloads (Singletons)

Autoloads (also called Singletons) are special scripts that stay loaded across all scenes. They’re perfect for storing global data, such as player stats, game state, settings, or audio managers.

Once registered, they’re available from anywhere in your game using their name.

Why Autoloads Are Needed

Autoloads make it easy to share data between scenes without constantly passing references around.

They’re great for things like:

Saving and loading game progress.
Keeping player stats between levels.
Handling global input or settings.
Managing background music, pause menus, or transitions.

They’re not great for:

Shared or per-instance values, like enemy health or temporary item states. If you store shared data such as enemy health in an autoload, then when one enemy dies, all others will die too.
Objects that exist multiple times in the world, such as bullets, items, or NPCs.
Autoloads are global, meaning every scene accesses the same data. Using them for per-object logic can cause synchronization issues or unexpected behavior between instances.

Setup

Create a new script, e.g. Global.gd.
Go to Project → Project Settings → Autoload.
Add your script and give it a name (e.g., Global).
Enable “Singleton.”

Now you can access it anywhere using that name.

Syntax

GDScript:

# GameManager.gd (autoload)
extends Node

var player_health = 100
var coins = 0

func add_coin():
    coins += 1

# Access the autoload directly from any other script
GameManager.add_coin()
print(GameManager.coins)

C#:

// GameManager.cs (autoload)
using Godot;

public partial class GameManager : Node
{
    public int PlayerHealth = 100;
    public int Coins = 0;
    public void AddCoin() => Coins++;
}

// Access the autoload directly from any other script
GameManager game = (GameManager)GD.Load("res://GameManager.cs");
game.AddCoin();
GD.Print(game.Coins);

I Made A Plugin To Update Godot From Within The Editor

Christine Coomans — Wed, 21 Aug 2024 14:31:12 GMT

I understand the struggle of not having the Steam version of Godot that auto-updates. If you’re like me, you might have been manually updating Godot via the website. This involves downloading the new stable version, extracting it, and then opening it. This tedious process has caused me to stick with older versions of Godot for much longer than I’d like to admit. As a result, I’m always late to enjoy the latest updates and features — which in the fast-paced world of game dev, is stressful.

For example, I didn’t download Godot version 4.2 until three months after its release because I was too lazy to visit the website and update it. This isn’t the first time I’ve done this. Even now, I haven’t updated my engine to Godot 4.3, which was released a week ago.

So, how can I fix this issue? Well, as a developer, I believe in working smarter — not harder. Instead of just manually updating by navigating to the website and clicking a button, I decided to invest hours of blood, sweat, and tears to create a plugin to automate this process. Easy, peasy.

And so my plugin was created. I’d like to share it with you, so you can update Godot within my editor and stay current with the latest version features. Okay, so let’s finally get rid of my ancient version of Godot and upgrade to Godot version 4.3.

Let’s start by opening up a blank project, and importing and activating my Plugin.

If activated and installed correctly, there should be a new workspace available at the top called “Godot Version Updater”.

Now, this workspace is made out of four parts:

A directory selector (where you want to save your engine);

A console (to show you what’s happening);

A panel showing version information (current, latest, and an option to enable .NET support);

A button to install the latest update.

By default, the plugin will download the latest version to your /Downloads folder. If you want to change this directory, click on the “NEW DIRECTORY” button.

If you are using Godot and GDScript, leave the “.NET Support Enabled” checkbox unchecked. If you are using Godot and C#, check this button so that it can install the .NET binaries.

When you’re ready, click the download button. You will see the console update you on the progress it's made. It might hang a bit on the “Starting download…” output because this is where it is downloading the update — so just be patient.

Once it’s done, it will open the directory where it has installed the update and it will highlight the executable file.

If you are on Linux/MacOS/Android, you will still have to manually extract the folder and open the executable. If you are on Windows, the plugin will automatically open up your project in the latest version of Godot.

It might seem that your old version is crashing, but this is just because the project is open in two different versions. Just exit the old version, and it should be fine.

If everything works, it should open up the latest version, and the “Current Version” value should be the same as the “Latest Version” value!

As you can see, my Godot has been updated from version 4.2.2 to version 4.3 without me having to manually do it on the website. Now whenever I need to update my project, I will just run my blank project with my plugin installed, and click the button. It will automatically fetch the latest version!

Conclusion

If you want to use my plugin to upgrade your Godot engine or just try it out, you can download it now:

GitHub
AssetLib (Awaiting Approval)

If you find bugs in this plugin, please let me know and I will get to fixing the plugin!

Going from Godot 3 to 4 (The Easy Way)

Christine Coomans — Fri, 09 Aug 2024 10:15:25 GMT

When I started learning Godot, I started with Godot 3. When Godot 4 came out, a lot of things changed — especially GDScript. To this day, I still type deg2rad instead of deg_to_rad, and nothing annoys me more than getting that error "Function "deg2rad()" not found in base self. Did you mean to use "deg_to_rad()"?"

You’d think I know better by now, but it’s a habit I can’t break. That’s why I decided to play around with a plugin for Godot to help upgrade your GDScript code from Godot 3 to Godot 4. This plugin automates the process of updating deprecated methods, properties, and syntax, ensuring your projects are compatible with the latest version of Godot.

All you have to do is download the plugin, add the folder to your project (your project/addons/upgrader/…), activate it, and paste in the code that you want to convert. Easy enough, right? 😅

Okay, you might not be convinced that this works, so let’s put it to the test by converting one of the very first 2D projects that I made in Godot 3 to Godot 4 — using only the plugin!

When I started learning, I came across this YouTube video that showed me how to make a simple farming system. It’s not the best looking and I never even completed the tutorial (wow, another unfinished project), but it made younger me feel like I had the power to make Stardew Valley 2.0. 😎

Let’s start by seeing what happens when I open my project that was made in Godot 3.2 the latest version of Godot.

The project setup, the warnings, the blurry textures — it’s giving me the heebie-jeebies. My scripts aren’t organized, my nodes are all over the place- and don’t even get me started on my file management skills. All of these are the artifacts left by beginner me, and I am proud to be the archeologist of this expedition. But we’re not here to critique the project, we’re here to see if the plugin works.

Before we do that, I’m going to upgrade my textures and fix all of the yellow warnings (mostly StaticBody2D nodes requiring collision shapes).

Much better! Now let’s see what happens when I try to run my project.

Uh-oh! I get an error. My scenes can’t run because the scripts all contain outdated code. If only there was a quick fix for that…oh wait, the plugin!

Let’s download the plugin and enable it in the project.

If enabled correctly, there should be a new dock on the left side of the editor. This dock has two parts: a code input and an output panel. We will paste our Godot 3 code in the input panel, and copy our Godot 4 code from the output panel.

Let’s start with our first script, which is our Player script. Here is the code:

As you can see, it uses KinematicBody3D and move_and_slide() with a parameter motion. In Godot 4, move_and_slide() does not call a parameter, and KinematicBody2D becomes CharacterBody2D. Let’s see if the plugin can detect these errors and fix it.

Paste in old code and press “Execute”:

New code should be upgraded automatically:

As you can see, it made the fixes automatically. Let’s paste these changes into our script.

No more errors! Okay, let’s do another script. The next script is used to “plant” seeds on a plot of land. As you can see below, it uses BUTTON_LEFT when it should be MOUSE_BUTTON_LEFT.

Let’s run it in the upgrader:

You’ll see it made the fixes and no more errors. Let’s do some more. Below it uses rand_range, when in Godot 4 it would be randf_range (for floats) or randi_range (for ints). The plugin made the conversion.

Great! One last one. The code below uses the old method of reading JSON files. The converter will not fully be able to replace your code, as your layout might differ, but it will give you a guide on how to do it. All you have to do is remove your old code, uncomment the guide, and copy in your file path. It’s easy!

With the code fixes out of the way, let’s run the code to see if it works. As I said, I never finished the tutorial, so all I could do in this project was drag seeds over the land to plant them and then after a few seconds they started to grow. Don’t judge me before you look at all the unfinished projects you might have. 😅

With my project working, I can now go back and add the finishing details, and Stardew Valley 2.0 will be live and ready to be published on Steam. Wish me luck! 😄

Conclusion

If you want to use my plugin to upgrade your code or try it out, you can download it now:

Please know that I might not have picked up all the changes, as there are a lot, so if you find ones that I haven’t added, you can let me know and I will implement those fixes into the plugin!

The Book of Nodes: 2D

Christine Coomans — Wed, 07 Aug 2024 12:44:25 GMT

Below you can find a list of 2D nodes that can be used in Godot 4. This is part of my Book of Nodes series. If you want to see similar content on 3D or UI nodes, please refer to the parent page of this post for those links. 😊

Before we begin, if you need a base project to test these code snippets, feel free to download my FREE 2D and 3D templates here. I’ll be using these templates throughout this post.

*Please note that this list is not 100% complete yet, but I will be updating this list as time goes on.

AnimatedSprite2D
AnimationPlayer
AnimationTree
Area2D
AudioStreamPlayer2D
Camera2D
CharacterBody2D
CollisionShape2D
DirectionalLight2D
LightOccluder2D
MeshInstance2D
NavigationAgent2D, NavigationObstacle2D, NavigationRegion2D
Node2D
Path2D, PathFollow2D
PointLight2D
RayCast2D
RigidBody2D
Sprite2D
StaticBody2D
TileMap
TileMapLayer
Timer

Node2D

The Node2Dnode is the fundamental building block for all 2D scenes in Godot. It provides us with basic 2D spatial features like position, rotation, and scale. Almost all 2D nodes (like Sprite2D, Area2D, etc.) inherit from Node2D, which makes it the most essential node for any 2D game development.

Mechanic:

Move a group of 2D nodes collectively.

Implementation:

Add a Node2D to your scene to serve as a parent node. This could represent a game object like a vehicle or a character.

Add child nodes such as twoSprite2Dnodes. These children can represent visual components, collision areas, etc.

In the Inspector, assign a texture (image file) of your choosing to the texture property of the Sprite2D node. This image will be what is displayed in the scene.

Now if we manipulate the Node2D parent, it will affect all its children. For example, moving the Node2D will move all its children, whilst maintaining their relative positions and transformations.

We can also do this via code — say if we press SPACE on our keyboard, the node moves -100 pixels on the x-axis.

### Main.gd

extends Node2D

@onready var node_2d = $Node2D

func _process(delta):
 if Input.is_action_pressed("ui_select"):
  node_2d.position.x -= 100 * delta

Sprite2D

The Sprite2Dnode in Godot is used to display 2D images in your scenes. Since it inherits from the Node2Dnode, it can handle various transformations like scaling, rotation, and translation. It’s one of the most commonly used nodes for representing characters, objects, and other visual elements in a 2D space.

You can use either a singular image as the texture, or a tilesheet.

If you are using a Tilesheet(as I am in this example) as your texture, you will have to crop out your sprite using the HFramesand VFramesproperty in the Inspector Panel. Then, add a key at each frame. The Frame Coords x property determines which column you are trying to access, and the Frame Coords y property determines which row you are trying to access.

Mechanic:

Display and animate a character.

Implementation:

Create a Sprite2D node in your scene.

In the Inspector, assign a texture (image file) to the texture property of the Sprite2D node. This image will be what is displayed in the scene.

Adjust the position, scale, and rotation properties to position the sprite correctly within your game world.

If you want to animate the sprite, you can use an AnimationPlayer to animate properties like position, rotation_degrees, and scale. You can also swap out the texture of the Sprite2D if you have a sprite that has multiple animations, for example walking, idling, etc.

Add the code to play the animation on load.

### Main.gd

extends Node2D

@onready var animation_player = $AnimationPlayer

func _ready():
 animation_player.play("move_character")

Run your project and your Sprite2D node should be in your scene. If you added an animation, it should play.

AnimatedSprite2D

The AnimatedSprite2D node utilizes a series of images (sprites) and displays them in a sequence to create an animation. Unlike a simple Sprite2D node that displays a single static image, AnimatedSprite2D can cycle through multiple frames to animate characters, objects, or effects within your 2D game. To create these frames, we can use either sprites or a spritesheet.

The AnimatedSprite2D node utilized the SpriteFrames Resource to create animations. This is a special resource in Godot that holds collections of images. Each collection can be configured as an animation by specifying the images (frames) that belong to it. You can create multiple animations within a single SpriteFrames resource, each with its own set of frames and playback properties like speed and loop settings.

Mechanic:

Create a character with walking animations.

Implementation:

Create an AnimatedSprite2D node in your scene.

Assign a SpriteFrames resource to the AnimatedSprite2D.

Add a new animation by clicking on the page+ icon.

Rename this animation by double-clicking on it.

Either drag in sprites into the frames box or click the spritesheet icon to add animations via an atlas.

Crop out the frames horizontally and vertically.

Select the frames you want. For instance, in my person atlas, I will choose frames 0–6 in row 5.

Then play the animation to see if you need to alter the FPS to make the character move faster/slower:

Repeat the process for all of your animations, for example walk_left, walk_up, walk_down, walk_up, idle_x, run_x, etc.

Play the animation in your code so that when your player moves during runtime the animation can play:

### Player.gd

extends CharacterBody2D

# Scene-Tree Node references
@onready var animated_sprite = $AnimatedSprite2D

# Variables
@export var speed = 100

# Input for movement
func get_input():
 var input_direction = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
 velocity = input_direction * speed

# Movement & Animation
func _physics_process(delta):
 get_input()
 move_and_slide()
 update_animation()
 
# Animation
func update_animation():
 if velocity == Vector2.ZERO:
  animated_sprite.play("idle")
 else:
  if abs(velocity.x) > abs(velocity.y):
   if velocity.x > 0:
    animated_sprite.play("walk_right")
   else:
    animated_sprite.play("walk_left")
  else:
   if velocity.y > 0:
    animated_sprite.play("walk_down")  
   else:
    animated_sprite.play("walk_up")

Run your project and move around:

AnimationPlayer

Unlike the AnimatedSprite2D which is specifically designed for sprite animations, the AnimationPlayer can animate virtually ANY node within a Godot scene. Instead of animating a simple sprite, you can animate the node’s properties — including but not limited to positions, rotations, scales, colors, and even variables.

The AnimationPlayer can hold a set of animations on a singular timeline, each containing keyframes that define the start and end points of any property that changes over time. You can create complex sequences and control animations in a non-linear fashion.

This node can be used to animate 2D, 3D, and even UI nodes!

Mechanic:

Animate a Sprite2D node of a potion that pulses in size to capture player's attention.

Implementation:

Add a Sprite2D node and an AnimationPlayer node to your scene. The Sprite2D node is the node we want to animate, and the property we want to animate of this node is its scale.

Assign a sprite to the Sprite2D node. I’ll assign a potion.

Select the AnimationPlayer node.
In the animation panel, click “New Animation” and name it something descriptive like “pulse”.

Set the animation length to the duration you want for one pulse cycle (e.g., 1 second).
Enable the “Loop” option to make the animation repeat continuously.

Go to the beginning of the animation timeline (0 seconds).
Select the Sprite2D node, and in the Inspector, set the scale property to its initial value (e.g., Vector2(1, 1)).
Right-click the scale property in the Inspector and select "Key" to add a keyframe.
Move to the middle of the timeline (e.g., 0.5 seconds), change the scale to a larger value (e.g., Vector2(1.2, 1.2)), and add another keyframe.
At the end of the timeline (1 second), set the scale back to the initial value (Vector2(1, 1)) and add a final keyframe.

You can control when the animation starts or stops via script, or let it run continuously since it’s set to loop.

### Main.gd

@onready var animation_player = $AnimationPlayer

func _ready():
    animation_player.play("pulse")

Start your project and observe the potion sprite pulsing in size.

MeshInstance2D

The MeshInstance2D node is used for displaying a Meshin a 2D space. In Godot, a mesh is used as a resource that can be applied to MeshInstance nodes to render geometry in a scene.

It can be particularly useful for achieving effects or visual styles that are difficult with standard 2D sprites or animations, such as deformations or complex shading that reacts to lighting conditions.

Mechanic:

Dynamically deform a 2D mesh (Sprite2D conversion).

Implementation:

Create a Sprite2D node in your scene. Assign it with a texture of your choice.

Use the editor’s conversion tool to convert it to MeshInstance2D node.

A dialog will appear, showing a preview of how the 2D mesh will be created. The yellow lines are the mesh polygons — and this will make up your 2D mesh shape. The default values are fine.

The Sprite2Dnode should be converted into a MeshInstance2Dnode.

Use scripts to deform the mesh dynamically.

### Main.gd

extends Node2D

@onready var sprite_2d = $Sprite2D

func _process(delta):
    var scale_factor = sin(Time.get_ticks_msec() / 1000.0) * 0.1 + 1.0
    sprite_2d.scale = Vector2(scale_factor, scale_factor)

Run the scene to observe the 2D mesh dynamically deform itself!

AnimationTree

The AnimationTree node enhances the capabilities of the AnimationPlayer by providing advanced features for animations, such as blending, transitions, and states. This makes it extremely easy to make detailed character animations and interactive scene elements in 2D and 3D environments.

We usually use blending to create smooth transitions between animations, for example, smoothly transitioning between walking and running depending on the player’s speed.

We use state machines to switch our animations dynamically depending on the conditions, for example, switching between idle and attack animations if the player presses a key.

Mechanic:

Animate a 2D character with multiple actions (e.g., walking, idle).

Implementation:

Add an AnimationPlayernode to your scene and create animations for it like "walk_x”, "idle". You’ll need to create these animations from a Sprite2Dnode, or else it won’t work.

Now, add an AnimationTree node, linking it to the AnimationPlayer.

Configure the tree_root as an AnimationNodeStateMachine for managing states.

Also assign the AnimationPlayeras the Anim Player property because this is where our AnimationTree will call the animations from, and the Advanced Expression as the root node because this is where our animation coding can be found (our script).

If you open your AnimationTree, you will see if you right-click you can add animations, blend trees, and state machines. Add your ‘idle’ animation and a BlendSpace2Dso that we can play our walk animations depending on our player's Vector2() coordinates. Rename the BlendSpace2D to ‘walk’.

Add a transition between start -> idle. The transition type should be immediatebecause we want the animation to play immediately.

Click the pencil icon to edit your walk BlendSpace2D. Then add a point with an animation at each coordinate. Up (0, -1). Down (0, 1). Left (-1, 0). Right (1, 0). Idle (0,0). Also change the blend mode to “Discrete”.

Add transitions between idle -> walk and vice versa. The transition type for both should be syncbecause we want to blend the animation. Also set the mode to enabledbecause we will activate this animation via the code, and not automatically.

Now in our code, we can play our animations based on our input.

### Player.gd

extends CharacterBody2D

# Scene-Tree Node references
@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")

# Variables
@export var speed = 100

# Input for movement
func get_input():
 var input_direction = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
 velocity = input_direction * speed

# Movement & Animation
func _physics_process(delta):
 get_input()
 move_and_slide()
 update_animation()

# Animation
func update_animation():
 var blend_position = Vector2.ZERO
 if velocity == Vector2.ZERO:
  animation_state.travel("idle")
 else:
  blend_position = velocity.normalized()
  animation_state.travel("walk")
 
 animation_tree.set("parameters/walk/blend_position", blend_position)

Run the scene and control the character to observe the transitions and movement based on our state.

CollisionShape2D

The CollisionShape2D node allows you to specify the boundaries of an object for collision detection, which is essential for handling interactions between objects in your game.

Mechanic:

Add a collision area to block the character from passing.

Implementation:

Create a CollisionShape2D node as a child of a CharacterBody2D, RigidBody2D, orStaticBody2D. These nodes will block other collisions. To have a node pass through collisions, use an Area2D.

In the Inspector, assign a Shape2D resource to the shape property of the CollisionShape2D. The shape you choose will depend on the shape of your entity. For example, a player might have a capsule shape, a pickup a circle, an area a box.

Let’s enable debugging to see our collisions in action.

Run your scene to see how your player interacts with the collision shape. Since we used a StaticBody2D node, they should be blocked and unallowed to go through the collision.

CharacterBody2D

The CharacterBody2D node is a specialized class for physics bodies that are meant to be controlled or moved around by the user. Unlike other physics bodies such as the RigidBody2Dor StaticBody2Dnode, CharacterBody2Dis not affected by the engine’s physics properties like gravity or friction by default. Instead, you have to write code to control its behavior, giving you precise control over how it moves and reacts to collisions.

Mechanic:

Move a character with arrow keys, including handling gravity and jumping.

Implementation:

Add a CharacterBody2D node to your scene.

You’ll see it has a warning icon next to it. This is because it needs a collision shape to be able to interact with the world. Add a CollisionShape2D as a child of the CharacterBody2D and set its shape to match your character.

Add a Sprite2D node to this scene so that we can see our character.

Attach a script to the CharacterBody2D to handle movement and jumping.

### Player.gd

extends CharacterBody2D

# Variables
@export var speed = 200
@export var jump_force = -400
@export var gravity = 800

# Input for movement
func get_input():
 velocity.x = 0
 if Input.is_action_pressed("ui_right"):
  velocity.x += speed
 if Input.is_action_pressed("ui_left"):
  velocity.x -= speed
 if Input.is_action_pressed("ui_down"):
  velocity.y -= jump_force
 if is_on_floor() and Input.is_action_just_pressed("ui_up"):
  velocity.y = jump_force

# Movement & Gravity
func _physics_process(delta):
 get_input()
 velocity.y += gravity * delta
 move_and_slide()

Run the scene and use the arrow keys to move the character and make it jump.

StaticBody2D

The StaticBody2D node is used to represent objects that do not move. This node is ideal for creating static elements in your game, such as walls, floors, and other immovable objects such as chests.

Mechanic:

Create an obstacle.

Implementation:

Create a StaticBody2D node in your scene. Add a CollisionShape2Das a child of the StaticBody and set its shape to match the obstacle.

Give it a Sprite2D of your choice so that we can see the item.

Run your scene to see how your player interacts with the collision shape. They should be blocked and unallowed to go through the obstacle.

RigidBody2D

The RigidBody2D node is used for objects that are affected by the engine’s physics. These bodies can move, rotate, and respond to forces and collisions. They are ideal for creating dynamic objects that need realistic physics interactions, such as balls, bullets, moveable obstacles, etc.

Mechanic:

Create a moveable obstacle.

Implementation:

Create a RigidBody2D node in your scene. Add a CollisionShape2Das a child of the RigidBody and set its shape to match the obstacle.

Give it a Sprite2D of your choice so that we can see the item.

Since we want to move this item when our player collides with it, we should disable its gravity so that it doesn’t get pulled downwards (unless you are making a 2D platformer).

Use GDScript to apply forces or impulses to the rigid body if the player pushes it.

### Player.gd

extends CharacterBody2D

# Scene-Tree Node references
@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")

# Variables
@export var speed = 100
@export var push_force = 80.0

# Input for movement
func get_input():
 var input_direction = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
 velocity = input_direction * speed

# Movement & Animation
func _physics_process(delta):
 get_input()
 move_and_slide()
 update_animation()
 handle_collisions()

# Animation
func update_animation():
 var blend_position = Vector2.ZERO
 if velocity == Vector2.ZERO:
  animation_state.travel("idle")
 else:
  blend_position = velocity.normalized()
  animation_state.travel("walk")
 
 animation_tree.set("parameters/walk/blend_position", blend_position)

# Handle Collisions
func handle_collisions():
 for i in range(get_slide_collision_count()):
  var collision = get_slide_collision(i)
  if collision.get_collider() is RigidBody2D:
   var collider = collision.get_collider() as RigidBody2D
   var impulse = -collision.get_normal() * push_force
   collider.apply_central_impulse(impulse)

Run the scene and observe how the obstacle moves when the player pushes against it.

Area2D

The Area2D node is used to detect when objects enter or exit a defined area. They do not represent physical bodies but are useful for triggering events such as cutscenes or map transitions, detecting overlaps, and creating zones for things such as enemy or loot spawning.

We can use the Area2D node’s on_body_entered() and on_body_exited() signals to determine whether or not a PhysicsBody has entered this zone.

Mechanic:

Create a trigger zone that detects when the player enters a specific area.

Implementation:

Create an Area2D node in your scene. You also need to add a CollisionShape2D as a child of the Area and set its shape to define the trigger zone. Adjust the collision shape's properties to fit the dimensions of your trigger zone.

Attach the Area2D node’s on_body_entered() and on_body_exited() signals to your script.

Use GDScript to notify us when the Player enters or exits the area.

### Main.gd

extends Node2D

func _on_area_2d_body_entered(body):
 if body.name == "Player":
  print("The player has entered the area!")

func _on_area_2d_body_exited(body):
 if body.name == "Player":
  print("The player has exited the area!")

Enable debugging so we can see when our Player enters/exits our area.

Run the scene and observe how the area detects when the Player enters or exits the defined zone. Each time the player enters/exits the zone, the game should be notified.

RayCast2D

The RayCast2D node is used to cast a ray in a 2D space to detect objects along its path. This is useful for various purposes such as line-of-sight checks, shooting and attacking mechanics, and collision detection.

It can collide with bodies such as StaticBody2D (useful for detecting loot and quest items), CharacterBody2D (useful for detecting interactions with enemies and NPCs), and RigidBody2D (useful for detecting interactions with moveable objects. It can also collide with areas, such as Area2D (useful for interactions with trigger zones).

Mechanic:

Cast a ray from the player and detect what it hits.

Implementation:

Add a RayCast2D node to the Player in your scene.

Set the target_position property to define the direction and length of the ray. I usually leave mine at its default values. You can also enable its collision with areas.

In the code, let’s update our raycast to always face the player’s last direction. We will also print the colliders it’s hitting.

### Player.gd

extends CharacterBody2D

# Scene-Tree Node references
@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")

# Variables
@export var speed = 100
var direction = Vector2()
@onready var ray_cast_2d = $RayCast2D

# Input for movement
func get_input():
 var input_direction = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
 direction = input_direction
 velocity = input_direction * speed

# Raycast hit detection
func _process(delta):
 if ray_cast_2d.is_colliding():
  var collider = ray_cast_2d.get_collider()
  print("Raycast hit: ", collider.name)

# Movement & Animation
func _physics_process(delta):
 get_input()
 move_and_slide()
 update_animation()
 
 # Update raycast to face player direction
 if direction != Vector2.ZERO:
  ray_cast_2d.target_position = direction.normalized() * 50

# Animation
func update_animation():
 var blend_position = Vector2.ZERO
 if velocity == Vector2.ZERO:
  animation_state.travel("idle")
 else:
  blend_position = velocity.normalized()
  animation_state.travel("walk")
 
 animation_tree.set("parameters/walk/blend_position", blend_position)

Run your scene and interact with objects that have colliders. The raycast should detect the objects and notify the game.

Camera2D

The Camera2D node is used to control the view of a 2D scene. It allows the screen to follow the player or other objects. Only one Camera can be active per viewport, and it registers itself in the nearest Viewport node.

In 2D games, we usually attach the Camera2D node to either the Player or our World scene. Attach it to the Player if you want to follow the player around. Attach the Camera to your World (Main) scene if you want a birds-eye view of the environment. This usually requires a bit more configuration and coding, as you have to make the camera able to move, rotate, scroll, or zoom around the scene.

Mechanic:

Create a “God Mode” 2D camera that can move, zoom, and rotate based on user input.

Implementation:

Add a Camera2D node to your Main (World) scene. Make sure this camera is enabled, and all other cameras are disabled.

Add the inputs to zoom and rotate your camera. The default up, down, left, and right inputs should be fine to move the camera.

Use GDScript to handle the camera’s zoom, movement, and rotation. You can do this in a custom Camera.gd script (preferred), or directly in your root script.

### Main.gd

extends Node2D

@onready var camera_2d = $Camera2D
@export var zoom_speed = 0.5
@export var move_speed = 200
@export var rotate_speed = 0.5
@export var min_zoom = 0.5
@export var max_zoom = 2.0

func _process(delta):
 handle_zoom(delta)
 handle_movement(delta)
 handle_rotation(delta)

# Zooming
func handle_zoom(delta):
 if Input.is_action_pressed("zoom_out"):
  camera_2d.zoom -= Vector2(zoom_speed, zoom_speed) * delta
 if Input.is_action_pressed("zoom_in"):
  camera_2d.zoom += Vector2(zoom_speed, zoom_speed) * delta
 camera_2d.zoom.x = clamp(camera_2d.zoom.x, min_zoom, max_zoom)
 camera_2d.zoom.y = clamp(camera_2d.zoom.y, min_zoom, max_zoom)

# Moving
func handle_movement(delta):
 var direction = Vector2.ZERO
 if Input.is_action_pressed("ui_right"):
  direction.x += 1
 if Input.is_action_pressed("ui_left"):
  direction.x -= 1
 if Input.is_action_pressed("ui_down"):
  direction.y += 1
 if Input.is_action_pressed("ui_up"):
  direction.y -= 1
 camera_2d.position += direction.normalized() * move_speed * delta

# Rotating
func handle_rotation(delta):
 if Input.is_action_pressed("rotate_left"):
  camera_2d.rotation -= rotate_speed * delta
 if Input.is_action_pressed("rotate_right"):
  camera_2d.rotation += rotate_speed * delta

Run the scene and use the defined input actions to move, zoom, and rotate the camera.

DirectionalLight2D

The DirectionalLight2D node is used to simulate sunlight or moonlight. It emits light in a specific direction, affecting all objects in the scene equally, regardless of their distance from the light source. This type of light is useful for outdoor scenes where you need consistent lighting across the entire scene.

This node’s two main properties are the energy and color properties. The energy property determines how bright/dim the light is, and the color is the shading of the light.

By default, I prefer NOT to use this node without shaders because its features are a bit unfinished (and the shadows are not good). If you’d like an introductory tutorial on how to use this node with shaders ( by making a day and night cycle), please check out my YouTube video.

Mechanic:

Illuminate a scene with sunlight.

Implementation:

Create a DirectionalLight2D node in your scene.

As you can see, this is crazy bright. Let’s adjust our properties like energy andcolorto customize the light's appearance and behavior.

Now let’s do something fun. I recommend using shaders with this node, but just for testing sake, let’s have it randomize its color each second.
Add a Timer node to your scene. In the Inspector Panel, enable autostart, and connect its timeout signal to your script

In your code, let’s randomize our light’s color every time the timer times out (every second).

### Main.gd

extends Node2D

@onready var directional_light_2d = $DirectionalLight2D

func _on_timer_timeout():
 directional_light_2d.color = Color(randf(), randf(), randf()

Run your scene and enjoy the overstimulation.

PointLight2D

The PointLight2D node emits light in all directions from a single point. This type of light is useful for creating focused lighting effects, such as flashlights, lamps, or fires.

This node’s two main properties are the energy , color, texture scale, and textureproperties. The energy property determines how bright/dim the light is. The color is the shading of the light. The textureproperty allows us to give our light a shape. The texture scale property determines the size of our light.

Mechanic:

Create a flickering torch.

Implementation:

In your scene, add a PointLight2D node. We’ll need to give it a shape, so download this texture, and drag it into your texture property.

Play around with the energy, color, andtexture scalevalues.

Just for fun, let’s give it a flicker effect. We’ll do this via an AnimationPlayer node.
Create a new animation in the AnimationPlayer.
Add a track for the energy property of the PointLight2D.
Add keyframes to the energy track to simulate flickering.
Enable looping, and change the blend mode to discrete.

Then play this animation via the code when the game loads.

### Main.gd

extends Node2D

@onready var animation_player = $AnimationPlayer

func _ready():
 animation_player.play("flicker")

Run the scene and observe the player’s color changes when they go into the flickering lights.

LightOccluder2D

The LightOccluder2D node is used to cast shadows from a light source that hits it. This light source can come from a DirectionalLight2D or PointLight2D. It requires an OccluderPolygon2D to define the shape of the occlusion.

Mechanic:

Cast a shadow from our player.

Implementation:

Create a LightOccluder2D node to the source you want to cast your shadows from.

You’ll see it has an error. This is because we need to draw a OccluderPolygon2D shape to define the shape of our shadow. Give your LightOccluder2D a new OccluderPolygon2D resource, and draw the polygon around your player. Make sure that you complete your polygon by connecting all of your points.

Now in our Main scene, we will need a light source to cast this shadow shape. Let’s add a PointLight2D node and put it above our player. Make sure its shadows are enabled so that it can cast this shadow.

Run your scene and watch the shadow move depending on where the light hits the occluder.

AudioStreamPlayer2D and AudioStreamPlayer

These nodes are used to play audio in our games. We use the AudioStreamPlayer to play audio equally across our scene (such as background music or ambient sounds), and the AudioStreamPlayer2D to play audio positionally (such as from our players or NPCs).

Mechanic:

Play ambient music in the background, and sounds from the player when they move.

Implementation:

Download your sound effects. You can find free ones on Pixabay. Look for ones that work well in the background (they loop), and ones that are short effects, such as jumping sounds.

Add an AudioStreamPlayer node to play background audio. Add an AudioStreamPlayer2D node to play positional audio.

You will need to reimport your audio that is supposed to loop. Double-click it, and enable looping.

Set the stream property to the desired audio file.

Adjust properties like volume_db, and pitch_scale if needed. We’ll enable autoplay on our AudioStreamPlayer node since that is our background music.

We will play our sound effect audio (AudioStreamPlayer2D) when our player enters a certain area. To do this, add an Area2D node to your scene with a collision body, and attach its on_body_entered() signal to your script.

Now play the audio when the player enters the area.

### Main.gd

extends Node2D

@onready var audio_stream_player_2d = $AudioStreamPlayer2D

func _on_area_2d_body_entered(body):
 if body.name == "Player":
  audio_stream_player_2d.play()

Run your scene. The background music should play, and the sound effect should play when your player enters the area.

NavigationAgent2D, NavigationObstacle2D, NavigationRegion2D

The NavigationAgent, NavigationObstacle, and NavigationRegion nodes are used to manage navigation and pathfinding in both 2D and 3D environments. These nodes help create dynamic and realistic movement for characters and objects, allowing them to navigate around obstacles and follow paths.

The NavigationAgent2Dnode is used to move characters along a path while avoiding obstacles.
The NavigationObstacle2Dnode is used to create obstacles that navigation agents will avoid.
The NavigationRegion2D node defines areas where navigation is allowed or restricted.

These three nodes combined allow us to create a more immersive world through mechanics such as NPC and Enemy roaming, particle movements, and controlled entity spawning.

Mechanic:

Create an NPC that roams around a certain area on the map.

Implementation:

In your Main scene, add a NavigationRegion2D to your scene to define the roaming area.

Create a new NavigationPolygonresource for this node so that we can define our region. Draw the polygon to where you want your region to be.

Now all we need to do is select our NavigationRegion node and select “Bake Navigation”. You’ll see a blue-colored polygon get drawn over our floor, that is our navigation region!

In a new scene, create your NPC using a CharacterBody2Dnode as the root node. Add the collisions and animations for this entity just as you did for your player.

To your NPC scene, add a NavigationAgent2D node. The NPC will be assigned to this agent so that they can roam in the region. Enable avoidance for this NPC so that they can avoid obstacles.

Attach a script to your NPC. We will then need to connect our signals from our NavigationAgent2D node to 1) compute the avoidance velocity of our NPC, and 2) redirect our NPC when that target is reached. For moving the NPC whilst avoiding obstacles, attach the velocity_computed signal to your script. For redirecting the NPC, attach the navigation_finished signal to your script.

We also want our NPC to pause before redirecting. To do this, we will add a Timer node to our scene. Enable its one_shot property, and change its wait_time to however long you want the NPC to wait before roaming again.

Also attach its timeout() signal to your script.

Now add your roaming functionality.

### NPC.gd

extends CharacterBody2D

@onready var navigation_agent_2d = $NavigationAgent2D
@onready var navigation_region = $"../NavigationRegion2D"
@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var timer = $Timer

# Variables
@export var movement_speed: float = 50.0
var roaming_area: Rect2 
var target_position: Vector2  

func _ready():
 # Add a delay to ensure the navigation map is loaded
 await get_tree().create_timer(1).timeout
 set_roaming_area()
 set_random_target()

func _physics_process(delta):
 # Move NPC towards the target
 var next_path_position = navigation_agent_2d.get_next_path_position()
 var new_velocity = (next_path_position - global_position).normalized() * movement_speed
 if navigation_agent_2d.avoidance_enabled:
  navigation_agent_2d.velocity = new_velocity
 else: 
  _on_navigation_agent_2d_velocity_computed(new_velocity)
 
 # Update the NPC's position
 move_and_slide()

 # Play walking animation
 update_animation(velocity)


func set_roaming_area():
 # Set the roaming area
 var navigation_polygon = navigation_region.get_navigation_polygon()
 if navigation_polygon.get_outline_count() > 0:
  var outline = navigation_polygon.get_outline(0)
  # Calculate the bounding rect
  var min_x = INF
  var min_y = INF
  var max_x = -INF
  var max_y = -INF
  for point in outline:
   min_x = min(min_x, point.x)
   min_y = min(min_y, point.y)
   max_x = max(max_x, point.x)
   max_y = max(max_y, point.y)
  roaming_area = Rect2(min_x, min_y, max_x - min_x, max_y - min_y)
 else:
  print("No outlines found in the navigation polygon.")


func set_random_target():
 # Set next roaming position within the roaming area
 target_position = Vector2(
  randf_range(roaming_area.position.x, roaming_area.position.x + roaming_area.size.x),
  randf_range(roaming_area.position.y, roaming_area.position.y + roaming_area.size.y)
 )
 navigation_agent_2d.set_target_position(target_position)

func update_animation(velocity: Vector2):
 if velocity.length() == 0:
  animation_state.travel("idle")
 else:
  animation_state.travel("walk")
  animation_tree.set("parameters/walk/blend_position", velocity.normalized())

func _on_navigation_agent_2d_velocity_computed(safe_velocity):
 # Move NPC
 velocity = safe_velocity

func _on_timer_timeout():
 # Move NPC again
 set_random_target()

func _on_navigation_agent_2d_navigation_finished():
 # When path reached, redirect NPC
 velocity = Vector2.ZERO
 animation_state.travel("idle")
 timer.start()

Instance your NPC in your Main scene. Move them into your region.

Optionally, add NavigationObstacle2D nodes to create obstacles. Add this node to a StaticBody2D with a collision shape.

Run your scene and see your NPC randomly roam. They should avoid your obstacles.

Path2D and PathFollow2D

The Path2D and PathFollow2D nodes work together to create and follow paths in a 2D space. The Path2D node is used to define a path using a sequence of points. I like this more than using a NavMesh because it allows you to create and visualize a path in the Godot editor, instead of randomizing it. The PathFollow2D node is used to make an object follow a path defined by a Path2D node.

Mechanic:

Create an NPC that roams on a defined path on the map.

Implementation:

Create a Path2D node in your scene.

Add a PathFollow2D node as a child of the Path2D.

Ensure the rotatesvalue of this path is disabled since our NPC should only move diagonally.

In a new scene, create your NPC using a CharacterBody2Dnode as the root node. Add the collisions and animations for this entity just as you did for your player.

Attach your NPC to your PathFollow2D node. This will tell the game that this is the object that should follow this Path.

Now we can draw our path. In the Godot editor, select the Path2D node. Use the “Add Point” button in the toolbar to add points to draw the path shape that your NPC has to follow. Select the point to move it on your map.

Add more points to complete your path.

With your path created, attach a script to your NPC. Then, add the logic for them to move along the path.

### NPC.gd

extends CharacterBody2D

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var path_follow = get_parent()

# Variables
@export var speed = 50.0
var current_offset = 0.0
var path_length = 0.0
var direction = 1

func _ready():
 # Get the total length of the path
 path_length = path_follow.get_parent().curve.get_baked_length()

func _physics_process(delta):
 # Update the progress along the path
 update_path_progress(delta)
 update_animation(Vector2(direction, 0))
 move_and_slide()

func update_path_progress(delta):
 # Update the progress along the path
 current_offset += speed * delta * direction
    # Reverse direction if the end or start of the path is reached
 if current_offset >= path_length or current_offset <= 0:
  direction *= -1 
 current_offset = clamp(current_offset, 0, path_length)
 path_follow.progress = current_offset

func update_animation(velocity: Vector2):
 if velocity.length() == 0:
  animation_state.travel("idle")
 else:
  animation_state.travel("walk")
  animation_tree.set("parameters/walk/blend_position", velocity.normalized())

Run your scene and see your NPC roam. They should follow your path in a zig-zag (back-and-forth) motion.

TileMap

The TileMap node allows us to create 2D grid-based levels. With it, we can place our objects directly onto a grid to draw our world.

The TileMap is composed of cells. Each cell has the same dimensions.

The TileMap uses a TileSet Resource that contains an array of 2D tiles that can be placed on cells on the grid. Each tile is comprised of a sprite, either from an atlas (tilesheet) or an individual image.

We can also add these tiles on different layers, which are added on top of other objects on the grid. These tiles can also have their own collision, navigation, and physics properties.

In my 2D base template project, you will see that my entire (very basic) world was made using several layers and tilesheets on the TileMap node.

Mechanic:

Create a tile-based map.

Implementation:

Let’s start by adding a TileMap node to our scene.

In the Inspector Panel, give this node a new TileSet resource.

You’ll see a panel open at the bottom. This is where we can add the sprites and tilesheets that we want to draw on our TileMap. To make it clear, we create tiles in the TileSet panel, and we draw these tiles onto our world in the TileMap panel.

Now, find a tilesheet or a sprite that you like, and drag it into this panel. Say yes to the prompt if you are using a tilesheet so that it can separate the tiles into grid cells.

Here we can give our tileset a name and change its margins (if necessary, usually it’s not).

In the Select and Paint panels, we can draw properties such as navigation, collision, or other physics properties onto our tiles. We’ll get to that in a bit.

Now, go to your TileMap panel. You will see that we can paint our tiles onto our screen. Using the tools, you can draw, erase, or select tiles that you have added.

You can also erase tiles by hovering over them and holding down your right mouse button.

You can rotate tiles via the X and Z keys on your keyboard.

You’ll see that we are drawing all the tiles on one layer. If you draw a tile over an existing one, it will replace that tile.

We don’t want this, so let’s add more layers. In the Inspector Panel, underneath Layers, press the “Add Element” button to add more layers.

Now we can draw on our different layers.

But what about collisions? For this, we need a Physics Layer. Click on the TileSet resource in your Inspector Panel, and navigate to Physics Layers.

Click “Add Element” to add a layer. You usually only need one layer for collisions.

Now go back to your TileSet panel, and navigate to the Paint pane. Select the Physics property, and select the layer you just created.

Now we can draw collisions wherever we want the player and other entities to be blocked. We usually only do this on objects such as trees, buildings, or the outer boundaries of our map.

To delete collisions, just clear your polygon on the left and click on your existing cells.

You can add more tilesheets and draw collisions on there too.

The last thing I want to show you is autotiling. Drawing the ground tile for tile, with all of its edges is extremely tedious. We can make use of autotiling, also called TERRAINS, to speed up this process. This feature automatically selects and places the appropriate tile based on the surrounding tiles, ensuring that the tiles blend seamlessly together.
Click on the TileSet resource in your Inspector Panel, and navigate to Terrain Sets.

We will add an Element for each resource we want to “autotile”. So if you added a tilesheet for dirt, grass, water, and mud in your TileSet panel, you will create an element for each of those resources. Since we only have the “Dirt” tilesheet (we don’t want to autotile foliage or buildings), we will only add one element.

If we had a “Grass” TileSet, we would add another element.

Now go back to your TileSet panel, and navigate to the Paint pane. Select the Terrains property, and select the layer you just created.

Now we will draw in our bits. This is what the engine will use to check the tiles for the appropriate variant to use. This might be confusing to you, but just remember to select all the areas of your tilemap that ARE NOT on weird shapes or corners.
You will have to play around with the tiles to find the bits that give you the best results.

Navigate back to your TileMap node, and go to the terrains property. You’ll see that your autotiles have been created.

Select your terrain and draw it onto the screen.

Go ahead and create your mini world. You can also select and drag commonly used tiles into the Patterns panel for easy access.

Run your scene and test your creation!

TileMapLayer

In Godot 4.3, the TileMap node has been replaced by TileMapLayer nodes. This node works exactly like the TileMap node, except each TileMapLayer node represents a single layer of tiles, making it easier to handle specific types of tiles separately (e.g., background, obstacles, interactive elements). This structure is meant to enhance our code clarity and allow for more granular control over the behaviors and properties of different tile layers.

Personally, I don’t like this way of TileMap creation because it reminds me too much of the way it was handled back in Godot 3. Now, instead of using one single TileMap node to create a map, we have to create many separate TileMapLayer nodes to achieve the same result. I guess I can’t complain because unless I make my own engine, this is the node that we will have to use going forward!

The way that we create collisions, autotiles, and tilesets is exactly the same as it was with the TileMap node — hence I left the details in for the TileMap node.

The TileMapLayer is composed of cells. Each cell has the same dimensions.

The TileMapLayer uses a TileSet Resource that contains an array of 2D tiles that can be placed on cells on the grid. Each tile is comprised of a sprite, either from an atlas (tilesheet) or an individual image.

To be able to create multiple layers of different tiles that can overlap with one another, we would have to create a TileMapLayer node for each layer.

In my 2D base template project, you will see that my entire (very basic) world was made using several TileMapLayer nodes. I added all of my layers to a Node2D node for better organization.

Mechanic:

Spawn an item on a TileMapLayer.

Implementation:

Let’s start by adding a TileMapLayernode to our scene. We will add this node to a Node2D node, renamed as “Map”.

In the Inspector Panel, give this node a new TileSet resource.

You’ll see a panel open at the bottom. This is where we can add the sprites and tilesheets that we want to draw on our TileMap. To make it clear, we create tiles in the TileSet panel, and we draw these tiles onto our world in the TileMap panel.

Now, find a tilesheet or a sprite that you like, and drag it into this panel. Say yes to the prompt if you are using a tilesheet so that it can separate the tiles into grid cells.

Here we can give our tileset a name and change its margins (if necessary, usually it’s not).

Now when we select the TileMap panel, we can select tiles from this TileSet resource and draw it onto our screen.

Let’s draw a large piece of dirt on our screen.

Now, let’s add another TileMapLayer node to our scene. This is the layer we want our item to spawn on. Also give it a TileSet resource.

Give it a tilesheet of your choice, and draw it on the screen.

Now, in our code, let’s add the functionality to spawn an item on our second (grass) TileMapLayer nodes only. In our script, we use these TileMapLayer methods to manage where items can spawn in a game:
get_used_rect(): This is used to find out the area of the TileMapLayer where tiles have been placed so that you can limit where items might appear to just these areas.
map_to_local(): This converts the position from the tile map's grid (which might be in big numbers like tile coordinates) to the actual position in the game world (which is in pixels), so you know exactly where to put an item.
get_cell_source_id(): This checks if a specific tile exists at a given position in the TileMapLayer. In our script, it's used to determine if a position is valid for spawning an item based on whether there's a tile from the sand or grass layer at that position.

### Main.gd

extends Node2D

# Node refs
var item_texture = load("res://Assets/Icons/icon1.png")
@onready var sand_layer = $Map/TileMapLayer
@onready var grass_layer = $Map/TileMapLayer2

var rng = RandomNumberGenerator.new()

func _ready():
 # Spawn between 5 and 10 items
 var spawn_item_amount = rng.randf_range(5, 10)
 await spawn_item(spawn_item_amount)  

# Valid item spawn location
func is_valid_spawn_location(layer, position):
 var cell_coords = Vector2(position.x, position.y)
 # Check if there's a tile on the sand layer
 if sand_layer.get_cell_source_id(cell_coords) != -1:
  return false
 # Check if there's a tile on the grass layer
 if grass_layer.get_cell_source_id(cell_coords) != -1:
  return true
 return false

# Spawn item
func spawn_item(amount):
 var spawned = 0
 var attempts = 0
 var max_attempts = 1000  # Arbitrary number, adjust as needed

 while spawned < amount and attempts < max_attempts:
  attempts += 1
  var random_position = Vector2(randi() % grass_layer.get_used_rect().size.x, randi() % grass_layer.get_used_rect().size.y)
  var layer = randi() % 2  
  if is_valid_spawn_location(layer, random_position):
   var item_instance = Sprite2D.new()
   item_instance.texture = item_texture
   item_instance.position = grass_layer.map_to_local(random_position) + Vector2(16, 16) / 2
   add_child(item_instance)
   spawned += 1

Run your scene and test to see if the items spawn on the green (grass) tiles which is the TileMapLayer2 node.

Timer

The Timer node is used to create countdown timers that can trigger events after a specified period. The Timer node provides several properties to control its behavior, including wait_time, autostart, and one_shot.

wait_time: The duration in seconds that the timer will count down before emitting the timeout signal.
autostart: If set to true, the timer will start automatically when the scene is loaded.
one_shot: If set to true, the timer will stop after emitting the timeout signal once. If false, the timer will restart automatically after each timeout.

It comes with a timeout signal, which is emitted when the timer reaches zero. This signal can be connected to a function to perform specific actions when the timer completes its countdown. The timeout signal is a crucial part of the Timer node's functionality, allowing you to trigger events at precise intervals.

Mechanic:

Spawn an enemy every 5 seconds.

Implementation:

Add a Timer node to your scene. Set its wait_time to 5 seconds. Since we want the enemy to “spawn” as soon as the game loads, we should enable its autostart property.

Connect the timer node’s timeout signal to your script. This will execute our logic to spawn our enemy every 5 seconds.

In your code, let’s “spawn” an enemy. Since we don’t have an actual enemy scene, we will just print the amount of enemies we have spawned.

### Main.gd

extends Node2D

@onready var timer = $Timer
var enemy_count = 0

func _ready():
 if not timer.is_stopped():
  timer.start()

func _on_timer_timeout():
 spawn_enemy()

func spawn_enemy():
 enemy_count += 1
 print("An enemy has spawned!")
 print("Current enemy count: ", enemy_count)

Run your game and your enemy should spawn each time the timer reaches 0!

The Book of Nodes: 3D

Christine Coomans — Wed, 07 Aug 2024 12:44:24 GMT

Below you can find a list of 3D nodes that can be used in Godot 4. This is part of my Book of Nodes series. If you want to see similar content on 2D or UI nodes, please refer to the parent page of this post for those links. 😊

Before we begin, if you need a base project to test these code snippets, feel free to download my FREE 2D and 3D templates here. I’ll be using these templates throughout this post.

*Please note that this list is not 100% complete yet, but I will be updating this list as time goes on.

AnimatedSprite3D
AnimationPlayer
AnimationTree
Area3D
AudioStreamPlayer3D
Skeleton3D, Bone3D, and BoneAttachment3D
Camera3D
CharacterBody3D
CollisionShape3D
DirectionalLight3D
GridMap
MeshInstance3D
NavigationAgent3D, NavigationObstacle3D, NavigationRegion3D
Node3D
OmniLight3D
Path3D, PathFollow3D
RayCast3D
RigidBody3D
Sprite3D
Spotlight3D
StaticBody3D
Timer
VehicleBody3D
WorldEnvironment

Node3D

The Node3Dnode is the fundamental building block for all 3D scenes in Godot. It is the base node for all 3D-related functionalities, providing 3D spatial features like position, rotation, and scale. Almost all 3D nodes (like CharacterBody3D, Area3D, etc.) inherit from Node3D, which makes it the core of any 3D scene structure in Godot.

Mechanic:

Rotate a group of 3D nodes collectively.

Implementation:

Add a Node3D to your scene to serve as a parent node. In an actual project, this could be used to represent a complex object like a spacecraft or a robot.

Add child nodes such as twoMeshInstance3Dnodes. These children can represent visual components, collision areas, etc.

Give the MeshInstance3Dnodes a shape of your choosing. I’m going to choose a BoxMeshshape.

Now if we manipulate the Node3D parent, it will affect all its children. For example, rotating the Node3D will rotate all its children, whilst maintaining their relative positions and transformations.

We can also do this via code — say every second the game runs the node should rotate around the y-axis pivot point.

### Main.gd

extends Node3D

@onready var node_3d = $Node3D

func _process(delta):
    node_3d.rotate_y(1.0 * delta)

MeshInstance3D

The MeshInstance3D node in Godot is used to display 3D geometry. It takes a Meshresource and instances it in the current scene, which is essential for rendering 3D models.

In Godot, a mesh is used as a resource that can be applied to MeshInstance3D nodes to render 3D geometry in a scene. Meshes in Godot can be created directly in the engine or imported from external 3D modeling tools such as Blender. Godot supports several 3D model formats for importing meshes, including .fbx, .gltf and .glb (glTF), .obj, and others.

You can use this node to display characters, objects, or even simple shapes for prototyping, such as cylinders, planes, cubes, etc.

Mechanic:

Display a 3D model in a game scene.

Implementation:

Create a MeshInstance3D node within your 3D scene.

In the Inspector, assign a mesh resource to the mesh property of the MeshInstance3D.

This is great for prototyping, but what if you created a Mesh in Blender and want to show that instead of a shape? Well, you can drag your imported objects directly into your scene.

You’ll see that it is added to your scene underneath a Node3Dnode which has been imported as a scene. To access the MeshInstance3Dchild node from this parent, you’ll have to localize the scene. Do this by right-clicking on the node, and selecting “Make Local”.

You can now add collisions to this node, or even materials and shaders.

Sprite3D

The Sprite3Dnode in Godot is used to display 2D images in a 3D environment. This node can be set to always face the camera, which makes it useful for billboards, decals, NPC headlines, and other elements that need to be visible from all angles in a 3D space.

Mechanic:

Display a billboard that always faces the player.

Implementation:

Create a Sprite3D node in your 3D scene.

Assign a texture to the texture property of the Sprite3D node in the Inspector. This texture will appear as a flat image in the 3D space.

Currently the image is just flat. To change this, enable the billboard_mode property of the Sprite3D to ensure it always faces the camera, making it visible from any angle.

Run the scene and navigate around the 3D world to see the sprite always facing towards the camera, behaving like a billboard.

AnimatedSprite3D

The AnimatedSprite3D node utilizes a series of images (sprites) and displays them in a sequence to create an animation in a 3D space. Unlike a simple Sprite3D node that displays a single static image in our world, AnimatedSprite3D can cycle through multiple frames to animate characters, objects, or effects within your 3D game. To create these frames, we can use either sprites or a spritesheet.

The AnimatedSprite3D node utilized the SpriteFrames Resource to create animations. This is a special resource in Godot that holds collections of images. Each collection can be configured as an animation by specifying the images (frames) that belong to it. You can create multiple animations within a single SpriteFrames resource, each with its own set of frames and playback properties like speed and loop settings.

Mechanic:

Animate a 3D spinning coin.

Implementation:

Download the spinning coin sheet.
Create an AnimatedSprite3D node in your scene.

Assign a SpriteFrames resource to the AnimatedSprite3D.

Add a new animation by clicking on the page+ icon.

Rename this animation by double clicking on it.

Either drag in sprites into the frames box, or click the spritesheet icon to add animations via our coin atlas.

Crop out the frames horizontally and vertically.

Select the frames you want. For instance, I will choose frames 0–4 in row 1.

Scale the coin down and move it to where you want it.

Then play the animation to see if you need to alter the FPS to make the coin rotate faster/slower.

Also enable billboard settings so that our image retains its 3D look and feel (instead of looking like a flat 2D coin).

Play the animation in your code so that when your player moves during runtime the animation can play:

### Main.gd

@onready var animated_sprite_3D = $AnimationSprite3D

func _ready():
    animated_sprite_3D.play("rotating_coin")

Start your project and observe the coin rotating around in your world.

AnimationPlayer

Unlike the AnimatedSprite3D which is specifically designed for image animations, the AnimationPlayer can animate virtually ANY node within a Godot scene. Instead of animating a simple sprite, you can animate the node’s properties — including but not limited to positions, rotations, scales, colors, and even variables.

This node can be used to animate 2D, 3D, and even UI nodes!

Mechanic:

Create a platform that moves up and down.

Implementation:

Add a MeshInstance3Dnode and an AnimationPlayernode to your scene. The MeshInstance3Dnode is the node we want to animate, and the property we want to animate of this node is its position.

Assign a shape to the MeshInstance3Dnode. I’ll assign a simple box shape.

Change its scale to be more similar to a platform — Vector3(2, 0.2, 2).

Select the AnimationPlayer node.
In the animation panel, click “New Animation” and name it something descriptive like “move_platform”.

Set the animation length to the duration you want for one pulse cycle (e.g., 1 second).
Enable the “Loop” option to make the animation repeat continuously.

Go to the beginning of the animation timeline (0 seconds).
Select the MeshInstance3D node, and in the Inspector, set the position property to its initial value (e.g., Vector3(0, 0, 0)).
Right-click the position property in the Inspector and select "Key" to add a keyframe.
Move to the middle of the timeline (e.g., 0.5 seconds), change the position to a larger value (e.g., Vector3(0, 1, 0)), and add another keyframe.
At the end of the timeline (1 second), set the position back to the initial value (Vector3(0, 0, 0)) and add a final keyframe.

You can control when the animation starts or stops via script, or let it run continuously since it’s set to loop.

### Main.gd

@onready var animation_player = $AnimationPlayer
func _ready():
    animation_player.play("move_platform")

Start your project and observe the platform move up and down.

AnimationTree

We usually use blending to create smooth transitions between animations, for example, smoothly transitioning between walking and running depending on the player’s speed.

We use state machines to switch our animations dynamically depending on the conditions, for example, switching between idle and attack animations if the player presses a key.

Mechanic:

Animate a 3D character with multiple actions (e.g., running, jumping, idle).

Implementation:

Add an AnimationPlayernode to your scene which has your 3D model, and create animations for it like "run", "attack", and "idle".

You can also download animations from Mixamo if you don’t want to manually create these. If you want to download an animation from Mixamo, you will have to upload your 3D character (MAKE SURE IT’S THE SAME CHARACTER AS THE ONE IN YOUR GAME) to the dashboard, and then download the skin along with your desired animation.
Then you’ll have to import the character with the animation into your project, add it to your scene, localize the scene, extract the animation (by saving it as a .res), and then you’ll have to load it into your original AnimationPlayer.
Now, add an AnimationTree node.

Configure the tree_root as an AnimationRootNode for managing states.

Also assign the AnimationPlayeras the Anim Player property because this is where our AnimationTree will call the animations from, and the Advanced Expression as the root node because this is where our animation coding can be found (our script).

If you open your AnimationTree, you will see if you right-click you can add animations, blend trees, and state machines. Add a new animation for ‘idle’, ‘walk’, ‘run’, and ‘jump’.

Add a transition between start -> idle. The transition type should be immediatebecause we want the animation to play immediately.

Add transitions between idle -> walk and vice versa. The transition type for both should be syncbecause we want to blend the animation. Also set the mode to enabledbecause we will activate this animation via the code, and not automatically.

Select your transitions from walk <-> idle, and in the Inspector panel, change the x-fade time to a value such as 0.3. This is the blending time of the transitions, which smoothens out our transition from one animation to the next.

Do the exact same for the transitions between your walk <-> sprint.

Do the same for your jump animation, but it should transition back to all of your other animations (jump -> idle, jump -> walk, jump -> sprint). The transition from your Jump to other animations should be of type At End, because we want to transition back to running, walking, or jumping when the player has finished jumping.

Then, we only want to JUMP if our player is jumping by pressing the ui_jump key. For this we can make use if an expression. We can enter boolean values in the expressionpanel, which will then check our code for the conditions to play the animation based on this boolean. So, if in our code we say is_jumping = true when we press our jump button, this part of the AnimationTree will execute.
Add an expression is_jumping to all of the transitions that go towards your jump animation (idle -> jump, walk -> jump, sprint -> jump).

Now in our code, we can play our animations.

### Player.gd

extends CharacterBody3D

# Vars
const run_speed = 3.0
const sprint_speed = 5.0
const jump_speed = 3.0
const gravity = 10

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var camera = $ThirdPersonCamera/Camera

var is_jumping = false

func _ready():
 Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _process(delta):
 handle_animation()

func _physics_process(delta):
 handle_movement(delta)

func handle_animation():
 var input_dir = Input.get_vector("ui_right", "ui_left", "ui_down", "ui_up")
 if is_jumping:
  if animation_state.get_current_node() != "jump":
   animation_state.travel("jump")
 elif input_dir.length() > 0:
  if Input.is_action_pressed("ui_sprint"):
   if animation_state.get_current_node() != "sprint":
    animation_state.travel("sprint")
  else:
   if animation_state.get_current_node() != "walk":
    animation_state.travel("walk")
 else:
  if animation_state.get_current_node() != "idle":
   animation_state.travel("idle")

func handle_movement(delta):
 # Check if the player has landed
 if is_on_floor() and velocity.y == 0:
  is_jumping = false
 # Apply gravity
 velocity.y += -gravity * delta

 # Get input direction
 var input_dir = Input.get_vector("ui_left", "ui_right", "ui_down", "ui_up")
 if input_dir.length() > 0:
  # Calculate movement direction based on camera orientation
  var forward = -camera.global_transform.basis.z
  var right = camera.global_transform.basis.x
  forward.y = 0  
  right.y = 0   
  forward = forward.normalized()
  right = right.normalized()
  var movement_dir = (forward * input_dir.y + right * input_dir.x).normalized()

  # Rotate player to face movement direction
  var target_rotation = atan2(movement_dir.x, movement_dir.z)
  rotation.y = lerp_angle(rotation.y, target_rotation, 0.1)

  # Apply movement
  if Input.is_action_pressed("ui_sprint"):
   velocity.x = movement_dir.x * sprint_speed
   velocity.z = movement_dir.z * sprint_speed
  else:
   velocity.x = movement_dir.x * run_speed
   velocity.z = movement_dir.z * run_speed
 else:
  velocity.x = move_toward(velocity.x, 0, run_speed)
  velocity.z = move_toward(velocity.z, 0, run_speed)

 # Handle jumping
 if Input.is_action_just_pressed("ui_jump") and is_on_floor():
  velocity.y = jump_speed
  is_jumping = true

 move_and_slide()

Run the scene and control the character to observe the transitions and movement based on our state.

CollisionShape3D

The CollisionShape3D node allows you to specify the boundaries of an object for collision detection, which is essential for handling interactions between objects in your game.

Mechanic:

Add a collision area to block the character from passing.

Implementation:

Create a CollisionShape3D node as a child of a CharacterBody3D, RigidBody3D, orStaticBody3D. These nodes will block other collisions. To have a node pass through collisions, use an Area3D.

In the Inspector, assign a Shape3D resource to the shape property of the CollisionShape3D. The shape you choose will depend on the shape of your entity. For example, a player might have a capsule shape, a pickup a sphere, an area a box.

Let’s enable debugging to see our collisions in action. You can also change the color of your debug lines to make it more visible.

Run your scene to see how your player interacts with the collision shape. Since we used a StaticBody3D node, they should be blocked and unallowed to go through the collision.

CharacterBody3D

The CharacterBody3D node is a specialized class for physics bodies that are meant to be controlled or moved around by the user. Unlike other physics bodies such as the RigidBody3D or StaticBody3D node, CharacterBody3D is not affected by the engine’s physics properties like gravity or friction by default. Instead, you have to write code to control its behavior, giving you precise control over how it moves and reacts to collisions.

Mechanic:

Move a character with arrow keys, including handling gravity and jumping.

Implementation:

Create a CharacterBody3D node in your scene.

You’ll see it has a warning icon next to it. This is because it needs a collision shape to be able to interact with the world. Add a CollisionShape3D as a child of the CharacterBody3D and set its shape to match your character.

Add a MeshInstance3D node to this scene so that we can see our character.

You’ll also need to attach a camera to your character so we can see them.

Attach a script to the CharacterBody3D to handle movement and jumping.

### Character.gd

extends CharacterBody3D

# Variables
@export var speed = 5.0
@export var jump_force = 10.0
@export var gravity = 10.0

# Input for movement
func get_input():
 velocity.x = 0
 velocity.z = 0
 if Input.is_action_pressed("ui_up"):
  velocity.z -= speed
 if Input.is_action_pressed("ui_down"):
  velocity.z += speed
 if Input.is_action_pressed("ui_left"):
  velocity.x -= speed
 if Input.is_action_pressed("ui_right"):
  velocity.x += speed
 if is_on_floor() and Input.is_action_just_pressed("ui_accept"):
  velocity.y = jump_force

# Movement & Gravity
func _physics_process(delta):
 get_input()
 velocity.y -= gravity * delta
 move_and_slide()

Run the scene and use the arrow keys to move the character and make it jump.

StaticBody3D

The StaticBody3D node is used to represent objects that do not move. This node is ideal for creating static elements in your game, such as walls, floors, and other immovable objects such as chests.

Mechanic:

Create an obstacle.

Implementation:

Create a StaticBody3D node in your scene. Add a CollisionShape3Das a child of the StaticBody and set its shape to match the obstacle.

Give it a MeshInstance3Dof your choice so that we can see the item.

Run your scene to see how your player interacts with the collision shape. They should be blocked and unallowed to go through the obstacle.

RigidBody3D

The RigidBody3D node is used for objects that are affected by the engine’s physics. These bodies can move, rotate, and respond to forces and collisions. They are ideal for creating dynamic objects that need realistic physics interactions, such as balls, bullets, moveable obstacles, etc.

Mechanic:

Create a moveable obstacle.

Implementation:

Create a RigidBody3D node in your scene. Add a CollisionShape3Das a child of the RigidBody and set its shape to match the obstacle.

Give it a MeshInstance3Dof your choice so that we can see the item.

Since we don’t want the object to fly into space when we collide with it, we will need to increase its mass value.

Use GDScript to apply forces or impulses to the rigid body if the player pushes it.

### Player.gd

extends CharacterBody3D

# Vars
const run_speed = 3.0
const sprint_speed = 5.0
const jump_speed = 3.0
const gravity = 10

@export var push_force = 80.0

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var camera = $ThirdPersonCamera/Camera

var is_jumping = false

func _ready():
 Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _process(delta):
 handle_animation()

func _physics_process(delta):
 handle_movement(delta)
 handle_collisions()

func handle_animation():
 var input_dir = Input.get_vector("ui_right", "ui_left", "ui_down", "ui_up")
 if is_jumping:
  if animation_state.get_current_node() != "jump":
   animation_state.travel("jump")
 elif input_dir.length() > 0:
  if Input.is_action_pressed("ui_sprint"):
   if animation_state.get_current_node() != "sprint":
    animation_state.travel("sprint")
  else:
   if animation_state.get_current_node() != "walk":
    animation_state.travel("walk")
 else:
  if animation_state.get_current_node() != "idle":
   animation_state.travel("idle")

func handle_movement(delta):
 # Check if the player has landed
 if is_on_floor() and velocity.y == 0:
  is_jumping = false
 # Apply gravity
 velocity.y += -gravity * delta

 # Get input direction
 var input_dir = Input.get_vector("ui_left", "ui_right", "ui_down", "ui_up")
 if input_dir.length() > 0:
  # Calculate movement direction based on camera orientation
  var forward = -camera.global_transform.basis.z
  var right = camera.global_transform.basis.x
  forward.y = 0  
  right.y = 0   
  forward = forward.normalized()
  right = right.normalized()
  var movement_dir = (forward * input_dir.y + right * input_dir.x).normalized()

  # Rotate player to face movement direction
  var target_rotation = atan2(movement_dir.x, movement_dir.z)
  rotation.y = lerp_angle(rotation.y, target_rotation, 0.1)

  # Apply movement
  if Input.is_action_pressed("ui_sprint"):
   velocity.x = movement_dir.x * sprint_speed
   velocity.z = movement_dir.z * sprint_speed
  else:
   velocity.x = movement_dir.x * run_speed
   velocity.z = movement_dir.z * run_speed
 else:
  velocity.x = move_toward(velocity.x, 0, run_speed)
  velocity.z = move_toward(velocity.z, 0, run_speed)

 # Handle jumping
 if Input.is_action_just_pressed("ui_jump") and is_on_floor():
  velocity.y = jump_speed
  is_jumping = true

 move_and_slide()
 
# Handle Collisions
func handle_collisions():
 for i in range(get_slide_collision_count()):
  var collision = get_slide_collision(i)
  if collision.get_collider() is RigidBody3D:
   var collider = collision.get_collider() as RigidBody3D
   var impulse = -collision.get_normal() * push_force
   collider.apply_central_impulse(impulse)

Run the scene and observe how the obstacle moves when the player pushes against it.

VehicleBody3D

TheVehicleBody3D node is used to simulate a 3D vehicle with realistic physics. It requires VehicleWheel3D nodes for each wheel to function correctly.

On our VehicleBody3D node, the most important properties are the engine_force, steer_angle, and brake_force properties. The engine_force allows our vehicle to move forward/backward. The steer_angle/steering properties allow our vehicle to move left/right. The brake_force property allows our car to stop.

Mechanic:

Create a controllable vehicle with wheels.

Implementation:

For this part, you will need to download a car and import it into your project. If you’re using my base template, I recommend downloading the Car Kit from Kenney and importing it into your project.

Create a VehicleBody3D node in your scene. You will need to give it a CollisionShape3D, and a mesh (use the one you imported).

Add VehicleWheel3D nodes as children of the VehicleBody3D node for each wheel. Name them FrontLWheel, BackLWheel, FrontRWheel, BackRWheel. Also move them into the positions of your wheels.

You’ll need to set your front wheels as the steering wheels, and your back wheels as your traction wheels.

Also attach a camera to your vehicle so you can follow it around.

Attach a script to your vehicle to handle the vehicle’s movement and control. We’ll move our car with our arrow keys, and brake with our spacebar.

# VehicleBody.gd

extends VehicleBody3D

@onready var front_l_wheel = $FrontLWheel
@onready var front_r_wheel = $FrontRWheel
@onready var back_r_wheel = $BackRWheel
@onready var back_l_wheel = $BackLWheel

# Variables
@export var new_engine_force = 1000.0
@export var brake_force = 500.0
@export var steer_angle = 0.5

func _process(delta):
 handle_input()

func handle_input():
 var engine = 0.0
 var brake = 0.0
 var steer = 0.0

 if Input.is_action_pressed("ui_up"):
  engine = new_engine_force
 if Input.is_action_pressed("ui_down"):
  engine = -new_engine_force
 if Input.is_action_pressed("ui_left"):
  steer = steer_angle
 if Input.is_action_pressed("ui_right"):
  steer = -steer_angle
 if Input.is_action_pressed("ui_accept"):
  brake = brake_force

 front_l_wheel.engine_force = engine
 front_r_wheel.engine_force = engine
 front_l_wheel.brake = brake
 front_r_wheel.brake = brake
 front_l_wheel.steering = steer
 front_r_wheel.steering = steer

Run your scene and try to control your vehicle. It should move around your map when controlled!

Area3D

The Area3D node is used to detect when objects enter or exit a defined area. They do not represent physical bodies but are useful for triggering events such as cutscenes or map transitions, detecting overlaps, and creating zones for things such as enemy or loot spawning.

We can use the Area3D node’s on_body_entered() and on_body_exited() signals to determine whether or not a PhysicsBody has entered this zone.

Mechanic:

Create a trigger zone that detects when the player enters a specific area.

Implementation:

Create an Area3D node in your scene. You also need to add a CollisionShape3D as a child of the Area and set its shape to define the trigger zone. Adjust the collision shape's properties to fit the dimensions of your trigger zone.

Attach the Area3D node’s on_body_entered() and on_body_exited() signals to your script.
Use GDScript to notify us when the Player enters or exits the area.

### Main.gd

extends Node3D

func _on_area_3d_body_entered(body):
 if body.name == "Player":
  print("The player has entered the area!")

func _on_area_3d_body_exited(body):
 if body.name == "Player":
  print("The player has exited the area!")

Enable debugging so we can see when our Player enters/exits our area.

Run the scene and observe how the area detects when the Player enters or exits the defined zone. Each time the player enters/exits the zone, the game should be notified.

RayCast3D

The RayCast3D node is used to cast a ray in a 3D space to detect objects along its path. This is useful for various purposes such as line-of-sight checks, shooting and attacking mechanics, and collision detection.

It can collide with bodies such as StaticBody3D (useful for detecting loot and quest items), CharacterBody3D (useful for detecting interactions with enemies and NPCs), and RigidBody3D (useful for detecting interactions with moveable objects. It can also collide with areas, such as Area3D (useful for interactions with trigger zones).

Mechanic:

Cast a ray from the player and detect what it hits.

Implementation:

Add a RayCast3D node to the Player in your scene.

Set the target_position property face the direction of your player (z: 1). You can also enable its collision with areas.

Now we can print what we are colliding with in our code.

### Player.gd

extends CharacterBody3D

# Vars
const run_speed = 3.0
const sprint_speed = 5.0
const jump_speed = 3.0
const gravity = 10

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var camera = $ThirdPersonCamera/Camera
@onready var ray_cast_3d = $RayCast3D

var is_jumping = false

func _ready():
 Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _process(delta):
 handle_animation()
 
    if ray_cast_3d.is_colliding():
        var collider = ray_cast_3d.get_collider()
        print("Raycast hit: ", collider.name)

Run your scene and interact with objects that have colliders. The raycast should detect the objects and notify the game.

Camera3D

The Camera3D node is used to control the view of a 3D scene. It allows the screen to follow the player or other objects. Only one Camera can be active per viewport, and it registers itself in the nearest Viewport node.

In third-person games, we usually attach the Camera3D node to a SpringArm3D node. The SpringArm node reacts to collisions in the environment. It ensures that the camera moves closer to the player when there are obstacles, preventing the camera from clipping through objects.

In first-person games, we usually attach the Camera3D directly to our Pivot — such as our Player head. This way we “see” from the player’s perspective.

In “God-Mode”, we attach the Camera to our World scene so that we can get a birds-eye view of the environment. This usually requires a bit more configuration and coding, as you have to make the camera able to move, rotate, and zoom.

Mechanic:

Create a “God Mode” 3D camera that can move, zoom, and rotate based on user input.

Implementation:

Add a Camera3D node to your Main (World) scene. Make sure this camera is set to ‘current’, and all other cameras are disabled.
Also move the camera up on the y-axis (10), and rotate it slightly on the x-axis (-45) to point down at your world.

Add the inputs to zoom, move, and rotate your camera.

Use GDScript to handle the camera’s zoom, movement, and rotation. You can do this in a custom Camera.gd script (preferred), or directly in your root script.

### Main.gd

extends Node3D

@onready var camera_3d = $Camera3D

@export var zoom_speed = 50.0
@export var move_speed = 5.0  # Adjusted to a more reasonable value
@export var rotate_speed = 0.5  # Adjusted to a more reasonable value
@export var min_zoom = 10.0
@export var max_zoom = 100.0

var target_fov = 70.0
var camera_drag = Vector2.ZERO
var camera_movement = Vector3.ZERO
var sensibility = 0.001

func _process(delta):
 handle_zoom(delta)
 handle_movement(delta)
 handle_rotation(delta)

func handle_zoom(delta):
 if Input.is_action_pressed("zoom_in"):
  camera_3d.fov -= zoom_speed * delta
 if Input.is_action_pressed("zoom_out"):
  camera_3d.fov += zoom_speed * delta
 camera_3d.fov = clamp(camera_3d.fov, min_zoom, max_zoom)

func handle_movement(delta):
 if Input.is_action_just_pressed("camera_drag"):
  camera_drag = get_viewport().get_mouse_position()
 if Input.is_action_pressed("camera_drag"):
  camera_movement.x += (get_viewport().get_mouse_position().x - camera_drag.x) * sensibility
  camera_movement.z += (get_viewport().get_mouse_position().y - camera_drag.y) * sensibility
 camera_3d.position += camera_movement * move_speed * delta
 camera_movement = lerp(camera_movement, Vector3.ZERO, 0.2)

func handle_rotation(delta):
 if Input.is_action_pressed("rotate_left"):
  camera_3d.rotate_y(rotate_speed * delta)
 if Input.is_action_pressed("rotate_right"):
  camera_3d.rotate_y(-rotate_speed * delta)

Run the scene and use the defined input actions to move, zoom, and rotate the camera.

DirectionalLight3D

The DirectionalLight3D node is used to simulate sunlight or moonlight in our 3D environment. It emits light in a specific direction, affecting all objects in the scene equally, regardless of their distance from the light source. This type of light is useful for outdoor scenes where you need consistent lighting across the entire scene.

This node’s two main properties are the energy and color properties. The energy property determines how bright/dim the light is, and the color is the shading of the light. You can also change the Mode of the shadows, which will change the way your shadows are rendered. By default, PSSM 2 is a good option to choose.

In 3D environments, your light will also be influenced by your WorldEnvironment node, which contains the sky of your world.

Mechanic:

Illuminate a scene with sunlight.

Implementation:

Create a DirectionalLight3D node in your scene.

By default, the light and energy looks pretty good. We can change these values if you want. For instance, we can make the energy brighter and the color darker to simulate night time.

Now let’s do something fun. I recommend using shaders with this node, but just for testing sake, let’s have it randomize its color each second.
Add a Timer node to your scene. In the Inspector Panel, enable autostart, and connect its timeout signal to your script

In your code, let’s randomize our light’s color every time the timer times out (every second).

### Main.gd

extends Node3D

@onready var directional_light_3d = $World/DirectionalLight3D

func _on_timer_timeout():
 directional_light_3d.color = Color(randf(), randf(), randf()

Run your scene and enjoy the overstimulation.

SpotLight3D

The SpotLight3D node emits light in a cone shape, illuminating objects within the cone’s range. This type of light is useful for creating focused lighting effects, such as flashlights or stage lights.

This node’s two main properties are the energy , color, specular, and range, and projectorproperties. The energy property determines how bright/dim the light is. The color is the shading of the light. The specular property affects how reflective surfaces appear under the spotlight. The range property defines the maximum distance the light can reach. The projector property allows us to give our light a texture, such as stained glass or a vignette effect.

Mechanic:

Create a flashlight attached to your player.

Implementation:

To your player, attach a Spotlight3D node. Move this node into one of their hands, and rotate it on the y-axis (180) so that it faces the direction that the player is facing.

Play around with the energy, range, angle, color, and specular values.

This light looks too bright. It needs to look more like a flashlight. Download this texture, and drag it into your projector property.

Now, let’s move this flashlight when we move our camera.

### Player.gd

extends CharacterBody3D

# Vars
const run_speed = 3.0
const sprint_speed = 5.0
const jump_speed = 3.0
const gravity = 10

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var camera = $ThirdPersonCamera/Camera
@onready var flashlight = $SpotLight3D

var is_jumping = false

func _ready():
 Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

func _process(delta):
 handle_animation()

func _physics_process(delta):
 handle_movement(delta)

func handle_animation():
 var input_dir = Input.get_vector("ui_right", "ui_left", "ui_down", "ui_up")
 if is_jumping:
  if animation_state.get_current_node() != "jump":
   animation_state.travel("jump")
 elif input_dir.length() > 0:
  if Input.is_action_pressed("ui_sprint"):
   if animation_state.get_current_node() != "sprint":
    animation_state.travel("sprint")
  else:
   if animation_state.get_current_node() != "walk":
    animation_state.travel("walk")
 else:
  if animation_state.get_current_node() != "idle":
   animation_state.travel("idle")

func handle_movement(delta):
 # Check if the player has landed
 if is_on_floor() and velocity.y == 0:
  is_jumping = false
 # Apply gravity
 velocity.y += -gravity * delta

 # Get input direction
 var input_dir = Input.get_vector("ui_left", "ui_right", "ui_down", "ui_up")
 if input_dir.length() > 0:
  # Calculate movement direction based on camera orientation
  var forward = -camera.global_transform.basis.z
  var right = camera.global_transform.basis.x
  forward.y = 0  
  right.y = 0   
  forward = forward.normalized()
  right = right.normalized()
  var movement_dir = (forward * input_dir.y + right * input_dir.x).normalized()

  # Rotate player to face movement direction
  var target_rotation = atan2(movement_dir.x, movement_dir.z)
  rotation.y = lerp_angle(rotation.y, target_rotation, 0.1)

  # Apply movement
  if Input.is_action_pressed("ui_sprint"):
   velocity.x = movement_dir.x * sprint_speed
   velocity.z = movement_dir.z * sprint_speed
  else:
   velocity.x = movement_dir.x * run_speed
   velocity.z = movement_dir.z * run_speed
 else:
  velocity.x = move_toward(velocity.x, 0, run_speed)
  velocity.z = move_toward(velocity.z, 0, run_speed)

 # Handle jumping
 if Input.is_action_just_pressed("ui_jump") and is_on_floor():
  velocity.y = jump_speed
  is_jumping = true

 move_and_slide()

 # Rotate flashlight to match camera orientation
 flashlight.global_rotation = camera.global_rotation

Run your scene and move your camera. Your flashlight should shine in that direction.

OmniLight3D

The OmniLight3D node emits light in all directions from a single point, similar to a light bulb. This type of light is useful for creating ambient lighting or point light sources.

Mechanic:

Create a flickering torch.

Implementation:

In your scene, add a OmniLight3D node. Move it to where you want your light to shine from.

Play around with the energy, range,color, and specular values.

Just for fun, let’s give it a flicker effect. We’ll do this via an AnimationPlayer node.
Create a new animation in the AnimationPlayer.
Add a track for the energy property of the OmniLight3D.
Add keyframes to the energy track to simulate flickering.
Enable looping.

Then play this animation via the code when the game loads.

### Main.gd

extends Node3D

@onready var animation_player = $AnimationPlayer

func _ready():
 animation_player.play("flicker")

Run the scene and observe the player’s color changes when they go into the flickering lights.

BoneAttachment3D

When importing a 3D model with a skeleton from 3D software such as Blender, the Skeleton3Dnode should automatically be populated with bones if the model is correctly rigged, exported, and imported. Bone3Dare the parts of the body — such as the hands, arms, legs, etc.

The BoneAttachment3Dnode is used to attach nodes to specific bones in a Skeleton3D. This allows you to dynamically attach objects to bones, which will follow the bone’s transformations. For example, we can attach a flashlight to our player’s hand, or a bow on our player’s back.

If we look at the Player character in the base template, we can see that their Skeleton3D node from is already populated with bones. This came from the model (.glb) itself — we didn’t have to manually create this in Godot.

Mechanic:

Attach a weapon to the right hand of our player.

Implementation Steps

In your Player scene, add aBoneAttachment3D node as a child of the Skeleton3D node.

Set the bone_name property of theBoneAttachment3D to the name of the bone you want to attach to. In our case, it should be the arm-right.

Add the objects you want to attach as children of the BoneAttachment3D nodes. In our case, we want to add a weapon. Since we don’t have weapons in the base template, we will use the cane instead.

Move the cane into the players hand.

In our script, let’s handle the attachment and detachment of this “weapon”. We also need to add an input to handle this action.

### Player.gd

extends CharacterBody3D

# Vars
const run_speed = 3.0
const sprint_speed = 5.0
const jump_speed = 3.0
const gravity = 10

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var camera = $ThirdPersonCamera/Camera

@onready var bone_attachment_3d = $"character-female-b2/character-female-b/Skeleton3D/BoneAttachment3D"

## Older code

func _input(event):
 if event.is_action_pressed("ui_equip"):
  equip_object()

func equip_object():
 bone_attachment_3d.visible = !bone_attachment_3d.visible

Run your scene. Your weapon should equip/unequip if you press TAB. When you move, the weapon should also move naturally with your bone.

AudioStreamPlayer3D and AudioStreamPlayer

These nodes are used to play audio in our games. We use the AudioStreamPlayer to play audio equally across our scene (such as background music or ambient sounds), and the AudioStreamPlayer3D to play audio positionally (such as from our players or NPCs).

Mechanic:

Play ambient music in the background, and sounds from the player when they move.

Implementation:

Download your sound effects. You can find free ones on Pixabay. Look for ones that work well in the background (they loop), and ones that are short effects, such as jumping sounds.

Add an AudioStreamPlayer node to play background audio. Add an AudioStreamPlayer3D node to play positional audio.

You will need to reimport your audio that is supposed to loop. Double click it, and enable looping.

Set the stream property to the desired audio file.

Adjust properties like volume_db, and pitch_scale if needed. We’ll enable autoplay on our AudioStreamPlayer node since that is our background music.

We also want to enable the emission property on our AudiostreamPlayer3D so that the audio can sound more distanced.

We will play our sound effect audio (AudioStreamPlayer3D) when our player enters a certain area. To do this, add an Area3D node to your scene with a collision body, and attach its on_body_entered() signal to your script.

Now play the audio when the player enters the area.

### Main.gd

extends Node3D

@onready var audio_stream_player_3d = $AudioStreamPlayer3D

func _on_area_3d_body_entered(body):
 if body.name == "Player":
  audio_stream_player_3d.play()

Run your scene. The background music should play, and the sound effect should play when your player enters the area.

WorldEnvironment

The WorldEnvironment node configures the default environment settings for a scene, including lighting, post-processing effects, and background settings. This node allows you to add a bunch of environmental effects, such as a skybox, fog, shadows, etc.

Everything you see in the screenshot below (the sky, light, fog) was done with the help of the WorldEnvironment node.

The most common properties you will change on this node will be:

Fog

Purpose: Fog makes distant objects fade into a uniform color, simulating atmospheric effects.
Key Properties:
Light Color: The color of the fog.
Density: The ‘thickness’ of the fog until it is fully opaque.
Sky Affect: Adjusts the fog color based on the sun’s energy.

Volumetric Fog

Purpose: Volumetric fog provides a more realistic fog effect by interacting with the lights in the scene.
Key Properties:
Density: The base exponential density of the volumetric fog.
Albedo: The color of the fog when interacting with lights.
Emission: The emitted light from the fog, useful for establishing ambient color.
Emission Energy: The brightness of the emitted light.
Anisotropy: The direction of scattered light through the fog.
Length: The distance over which the fog is computed.
Detail Spread: The distribution of detail in the fog.
Ambient Inject: Scales the strength of ambient light used in the fog.
Sky Affect: Controls how much the fog affects the background sky.

Glow

Purpose: Glow adds bloom effects to bright areas, enhancing the visual appeal.
Key Properties:
Intensity: The strength of the glow effect.
Strength: The brightness for the glow effect.
Blend Mode: The blending mode for the glow effect.

Tonemapping

Purpose: Tonemapping adjusts the color balance and contrast of the scene.
Key Properties:
Mode: The tone-mapping algorithm (e.g., Linear, Reinhard, Filmic).
Exposure: Adjusts the overall exposure of the scene.

Ambient Light

Purpose: Ambient light provides a base level of illumination for the scene, ensuring that no part of the scene is completely dark.
Key Properties:
Color: The color of the ambient light.
Energy: The intensity of the ambient light.
Sky Contribution: The amount of light contributed by the sky.

Sky

Purpose: The sky provides the background for the scene, which can be a solid color, a skybox, or a custom shader.
Key Properties:
Sky: The type of sky (e.g., PanoramaSky, ProceduralSky).
Custom FOV: The intensity of the sky’s contribution to the scene lighting.

Background

Purpose: The background sets the visual backdrop for the scene, which can be a solid color, a sky, or a custom shader.
Key Properties:
Mode: The background mode (e.g., Clear Color, Sky, Custom Color).
Energy Multiplier: The intensity of the background’s contribution to the scene lighting.

Mechanic:

Create a spooky atmosphere.

Implementation:

Add a WorldEnvironment node to your scene. To this node, add an Environment resource and configure it.

Set the background to be a color. Set the color to be black.

Change the ambient light color and energy.

Everything is too dark. Let’s enable our fog and change our properties.

Let’s lighten the mood. Enable the glow property, and change its properties.

Run your scene. Your game should look a little bit more spooky now!

NavigationAgent3D, NavigationObstacle3D, NavigationRegion3D

The NavigationAgent3Dnode is used to move characters along a path while avoiding obstacles.
The NavigationObstacle3D node is used to create obstacles that navigation agents will avoid.
The NavigationRegion3D node defines areas where navigation is allowed or restricted.

These three nodes combined allow us to create a more immersive world through mechanics such as NPC and Enemy roaming, particle movements, and controlled entity spawning.

Mechanic:

Create an NPC that roams around a certain area on the map.

Implementation:

In your Main scene, add a NavigationRegion3D to your scene to define the roaming area.

Create a new NavigationMesh resource for this node so that we can define our region. Also move it to where you want your region to be.

Now to actually add our region, we’ll need to add our “floor” as a child of this NavigationRegion node. Since I’m not sure if you are using Terrains or GridMaps, we’ll use a MeshInstance3D for this.
Add a MeshInstance3D node as a child to this node. Change its size to something like 10 x 10 m.

Move your region so the floor is below the grass.

Now all we need to do is select our NavigationRegion node and select “Bake Navigation”. You’ll see a blue-colored polygon get drawn over our floor, that is our navigation region!

In a new scene, create your NPC using a CharacterBody3Dnode as the root node. Add the collisions and animations for this entity just as you did for your player.

To your NPC scene, add a NavigationAgent3D node. The NPC will be assigned to this agent so that they can roam in the region. Enable avoidance for this NPC so that they can avoid obstacles.

Attach a script to your NPC. We will then need to connect our signals from our NavigationAgent3D node to 1) compute the avoidance velocity of our NPC, and 2) redirect our NPC when that target is reached. For moving the NPC whilst avoiding obstacles, attach the velocity_computed signal to your script. For redirecting the NPC, attach the navigation_finished signal to your script.

We also want our NPC to pause before redirecting. To do this, we will add a Timer node to our scene. Enable its one_shot property, and change its wait_time to however long you want the NPC to wait before roaming again.

Also attach its timeout() signal to your script.

Now add your roaming functionality.

### NPC.gd

extends CharacterBody3D

@onready var navigation_agent_3d = $NavigationAgent3D
@onready var navigation_region = $"../NavigationRegion3D/MeshInstance3D"
@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var timer = $Timer

# Variables
@export var movement_speed: float = 1.0
var roaming_area: AABB
var target_position: Vector3

func _ready():
 # Add a delay to ensure the navigation map is loaded
 await get_tree().create_timer(1).timeout
 set_roaming_area()
 set_random_target()

func _physics_process(delta):
 # Move NPC towards the target
 var next_path_position: Vector3 = navigation_agent_3d.get_next_path_position()
 var new_velocity: Vector3 = global_position.direction_to(next_path_position) * movement_speed
 if navigation_agent_3d.avoidance_enabled:
  navigation_agent_3d.velocity = new_velocity
 else:
  _on_navigation_agent_3d_velocity_computed(new_velocity)
 
 # Rotate NPC to face the direction of movement
 if velocity.length() > 0:
  var target_rotation = atan2(velocity.x, velocity.z)
  rotation.y = lerp_angle(rotation.y, target_rotation, 0.1)
 
 # Play walking animation
 if velocity != Vector3.ZERO:
  animation_state.travel("walk")
 else:
  animation_state.travel("idle")
 
 move_and_slide()

func set_roaming_area():
 # Set the roaming area based on the MeshInstance3D's bounding box
 roaming_area = navigation_region.get_aabb()
 print("Roaming area: ", roaming_area)

func set_random_target():
 # Set next roaming position
 target_position = Vector3(
  randf_range(-roaming_area.position.x, roaming_area.position.x),
  randf_range(-roaming_area.position.y, roaming_area.position.y),
  randf_range(-roaming_area.position.z, roaming_area.position.z)
 )
 navigation_agent_3d.set_target_position(target_position)

func _on_navigation_agent_3d_velocity_computed(safe_velocity):
 # Move NPC
 velocity = safe_velocity

func _on_timer_timeout():
 # Move NPC again
 set_random_target()

func _on_navigation_agent_3d_navigation_finished():
 # When path reached, redirect NPC
 velocity = Vector3.ZERO
 animation_state.travel("idle")
 timer.start()

Instance your NPC in your Main scene. Move them into your region.

Optionally, add NavigationObstacle3D nodes to create obstacles. Add this node to a mesh with a collision shape.

Run your scene and see your NPC randomly roam. They should avoid your obstacles.

Path3D and PathFollow3D

The Path3D and PathFollow3D nodes work together to create and follow paths in a 3D space. The Path3D node is used to define a path using a sequence of points. I like this more than using a NavMesh because it allows you to create and visualize a path in the Godot editor, instead of randomizing it. The PathFollow3D node is used to make an object follow a path defined by a Path3D node.

Mechanic:

Create an NPC that roams on a defined path on the map.

Implementation:

Create a Path3D node in your scene.

Add a PathFollow3D node as a child of the Path3D.

Enable its use_model_front property so that our NPC will always move whilst facing the front.

In a new scene, create your NPC using a CharacterBody3Dnode as the root node. Add the collisions and animations for this entity just as you did for your player.

Attach your NPC to your PathFollow3D node. This will tell the game that this is the object that should follow this Path.

Now we can draw our path. In the Godot editor, select the Path3D node. Use the “Add Point” button in the toolbar to add points to draw the path shape that your NPC has to follow. Select the point to move it on your map.

Add more points to complete your path.

Make sure your path is on the ground, otherwise your NPC will fly!

With your path created, attach a script to your NPC. Then, add the logic for them to move along the path.

### NPC.gd

extends CharacterBody3D

@onready var animation_tree = $AnimationTree
@onready var animation_state = animation_tree.get("parameters/playback")
@onready var path_follow = get_parent()

# Vars
@export var movement_speed: float = 2.0
var current_offset: float = 0.0
var path_length: float = 0.0
var direction: int = 1
var previous_position: Vector3 = Vector3.ZERO

func _ready():
 # Get the total length of the path
 path_length = path_follow.get_parent().curve.get_baked_length()

func _physics_process(delta):
 # Update the progress along the path
 update_path_progress(delta)
 
 # Calculate the velocity based on the change in position
 var current_position = path_follow.global_transform.origin
 var velocity = (current_position - previous_position) / delta
 previous_position = current_position
 
 # Update the animation based on the velocity
 update_animation(velocity)
 
 # Update the NPC's position to follow the PathFollow3D node
 global_transform.origin = current_position
 
 # Rotate NPC to face the direction of movement
 if velocity.length() > 0:
  var target_rotation = atan2(velocity.x, velocity.z)
  rotation.y = lerp_angle(rotation.y, target_rotation, 0.1)
 
 move_and_slide()

func update_path_progress(delta):
 current_offset += movement_speed * delta * direction

 # Reverse direction if the end or start of the path is reached
 if current_offset >= path_length or current_offset <= 0:
  direction *= -1  # Reverse the direction
 current_offset = clamp(current_offset, 0, path_length)
 
 # Update the progress of the PathFollow3D node
 path_follow.progress = current_offset

func update_animation(velocity: Vector3):
 if velocity.length() == 0:
  animation_state.travel("idle")
 else:
  animation_state.travel("walk")
  animation_tree.set("parameters/walk/blend_position", velocity.normalized())

Run your scene and see your NPC roam. They should follow your path in a zig-zag (back-and-forth) motion.

GridMap

The GridMap node allows us to create 3D grid-based levels. With it, we can place our 3D models (tiles) on a grid interactively, similar to how TileMap works in 2D. If you have suitable models, you can use them to create, design, and manage large, repetitive environments like dungeons, cities, or landscapes.
The Gridmap is composed of cells. Each cell has the same dimensions.

These cells are formed using floors (horizontal grid), and planes (vertical grid). Each floor represents a different height level, whereas each plane represents a different depth level.

The GridMap uses a MeshLibrary Resource that contains an array of 3D tiles that can be placed on cells on the grid. Each tile is a mesh with materials, and it can also include optional collision and navigation shapes.

In my 3D base template project, you will see that my entire world was made using several GridMap nodes.

All of these tiles that you see on the screen were originally .glb models.

We add all of these models to a new scene, add whatever collisions we want, and then we convert this entire scene into MeshLibrary Resources so that they can be used by our GridMap as tiles.

Mechanic:

Create a grid-based map.

Implementation:

To begin, we need a MeshLibrary, which is a collection of individual meshes that can be used in the GridMap.
Create a new scene with a Node3D node as the root node. Rename this node to “GridTiles”.

Import any .glb asset that you want to use, and then drag it into this new scene.

If you added meshes that need to block the player or the player should be able to walk on it (such as the ground), you’ll have to localize these scenes and add a collision shape to them.

After this is done, you can navigate to Scene > Export As and export this scene as a MeshLibrary.

Now we can add these to a GridMap. In your Main scene, add a new GridMap node.

Assign the library that you just created as its MeshLibrary resource. The tiles should now be available to be placed down.

If your meshes look odd, you can change the cell size to fit your mesh, as well as disable centering on a certain axis so it “snaps” better.

You can alter between floors and planes by pressing the C, X, and Z keys on your keyboard.

You can delete tiles by hovering over them and holding down your right mouse button.

You can rotate meshes via the D and S keys on your keyboard.

You will have to use multiple GridMaps with different settings to achieve a good result. Unless you’re using tiles that are all the same size, you won’t be able to do everything using only one GridMap.

Go ahead and create your mini world.

Run your scene and test your creation!

Timer

wait_time: The duration in seconds that the timer will count down before emitting the timeout signal.
autostart: If set to true, the timer will start automatically when the scene is loaded.
one_shot: If set to true, the timer will stop after emitting the timeout signal once. If false, the timer will restart automatically after each timeout.

Mechanic:

Spawn an enemy every 5 seconds.

Implementation:

Add a Timer node to your scene. Set its wait_time to 5 seconds. Since we want the enemy to “spawn” as soon as the game loads, we should enable its autostart property.

Connect the timer node’s timeout signal to your script. This will execute our logic to spawn our enemy every 5 seconds.

In your code, let’s “spawn” an enemy. Since we don’t have an actual enemy scene, we will just print the amount of enemies we have spawned.

### Main.gd

extends Node3D

@onready var timer = $Timer
var enemy_count = 0

func _ready():
 if not timer.is_stopped():
  timer.start()

func _on_timer_timeout():
 spawn_enemy()

func spawn_enemy():
 enemy_count += 1
 print("An enemy has spawned!")
 print("Current enemy count: ", enemy_count)

Run your game and your enemy should spawn each time the timer reaches 0!

The Book of Nodes: UI

Christine Coomans — Wed, 07 Aug 2024 12:43:46 GMT

Below you can find a list of UI nodes that can be used in Godot 4. This is part of my Book of Nodes series. If you want to see similar content on 2D or 3D nodes, please refer to the parent page of this post for those links. 😊

Before we begin, if you need a base project to test these code snippets, feel free to download my FREE 2D and 3D templates here. I’ll be using these templates throughout this post.

*Please note that this list is NOT 100% complete yet, but I will be updating this list as time goes on.

Control
CanvasLayer
CanvasModulate
Container
HBoxContainer
VBoxContainer
GridContainer
ColorRect
Panel
Button
Label
RichTextLabel
ProgressBar

Common Properties

Anchoring

Determines how a UI element is positioned and resized relative to its parent container.
anchor_left: Sets the left anchor point (0 to 1).
anchor_top: Sets the top anchor point (0 to 1).
anchor_right: Sets the right anchor point (0 to 1).
anchor_bottom: Sets the bottom anchor point (0 to 1).
full_rect: Sets the anchor point to all sides.

Margins

Defines the distance between the UI element and its parent container’s edges.
margin_left: Distance from the left edge.
margin_top: Distance from the top edge.
margin_right: Distance from the right edge.
margin_bottom: Distance from the bottom edge.

Font

Customizes the appearance of text within UI elements.
font: The font resource used for the text.
font_size: The size of the font.
font_color: The color of the font.

Color

Customize the color properties of UI elements.
color: The main color of the UI element.
font_color: The color of the text.
modulate: The alpha value applied to the UI element.

Transform

Controls the position, rotation, and scale of UI elements.
position: The position of the UI element.
rotation: The rotation of the UI element in degrees.
scale: The scale of the UI element.

Size Flags

Determines how a UI element resizes within its parent container.
size_flags_horizontal: Horizontal resizing behavior (e.g., fill, expand).
size_flags_vertical: Vertical resizing behavior (e.g., fill, expand).

Visibility

Controls the visibility of UI elements.
visible: Whether the UI element is visible.
self_modulate: The color modulation applied to the UI element, affecting its visibility.

Focus

Manages keyboard and controller focus for UI elements.
focus_mode: Determines if the UI element can receive focus (none, click, all).
focus_neighbour_*: Specifies neighboring UI elements for focus navigation (up, down, left, right).

Tooltip

Provides additional information when the user hovers over a UI element.
hint_tooltip: The text displayed as a tooltip.

Theme Overrides

Allows customization of the UI element’s appearance beyond the default theme.
theme: The theme resource applied to the UI element.
theme_type_variation: A variation of the theme type for more specific customization.

Control

A Control node provides a bounding rectangle on the viewport that can be used for creating user interfaces in Godot, as they handle input events, focus, and other UI-specific functionalities.

Mechanic:

Drag and drop a sprite on the map.

Implementation:

Add a Control node to your scene. This represents the item you will drag and drop.

We need to visualize it, so add a TextureRect node to it. This node allows us to add a sprite to the control so that we can see what we are moving. This works better than the Sprite2D/3D node because it can be anchored to our Control container.

Add any texture (icon) to this TextureRect.

Attach a script to your Control node. To be able to drag and drop this object, we will need to connect its gui_input() signal to our script.

In your code, add the functionality to select the item using the LEFT mouse button. Use set_drag_preview to show a visual representation of the item being dragged.
Then, add the functionality to drop your item on the LEFT mouse button release.
And then also add the functionality to snap the item to your mouse cursor whilst dragging it around.

### Control.gd

extends Control

var drag_offset = Vector2.ZERO
var is_dragging = false

func _on_gui_input(event):
 if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT:
  # Select
  if event.pressed:
   is_dragging = true
   if get_viewport().gui_is_dragging():
    set_drag_preview(self)
  else:
   # Drop
   is_dragging = false
 # Drag
 elif event is InputEventMouseMotion and is_dragging:
  var global_pos = get_global_mouse_position()
  global_position = global_pos - size / 2

Test your logic by selecting the item and dragging it around.

CanvasLayer

A CanvasLayer is used for independent rendering of objects within a 2D scene, often for UI elements or HUDs. It renders its child nodes independently of the main scene's camera, which means that they remain fixed on the screen.

Example Use Cases:

HUD (Heads-Up Display).
Fixed-position UI elements.
Overlay menus.

Mechanic:

To demonstrate the use of the layer property, we will create a simple scene with two CanvasLayer nodes. One will be used for a background layer, and the other for a UI layer. The background layer will be drawn behind the UI layer.

Implementation:

Add two CanvasLayernodes to your scene.

Add a Label node to the first CanvasLayer node. Add a ColorRect to the second CanvasLayer node.

Give the Label some text, and change the ColorRects color to a dark grey. Also, change its anchor-preset to be full_rect.

You will see that our label isn’t showing, because our first CanvasLayer node has the same Layer value as the second CanvasLayer.
Change the first CanvasLayer node’s Layer value to be “2”.

Your label should now be on top of the background!

Container

A Container is used to organize UI elements, providing a base class for various container types. It inherits from Control and provides functionality for arranging child nodes. We usually don’t use this node a lot, as a normal Control node suffices.

You might, however, use a ScrollContainer node. A ScrollContainer is a type of container node in Godot that provides scrollbars to its child control when needed. It is useful for creating scrollable areas in your UI, such as lists, text areas, or any content that exceeds the visible area of the container.

Example Use Cases:

Base class for custom container types.
Organizing complex UI layouts.
Creating custom layout behaviors.

HBoxContainer

An HBoxContainer is used to arrange UI elements horizontally. It inherits from Container and arranges its children in a horizontal line.

Example Use Cases:

Horizontal menus.
Toolbars.
Row-based layouts.

Mechanic:

Arrange a list of items horizontally on the scene.

Implementation:

Add a Control node to your scene. This will hold our HBoxContainer. Change its size to something like 600px by 600px to give it a bounding area.

Add a HboxContainer node to this Control node. Also, make sure its anchor preset is full_rect so that it takes up the entire space provided by the Control node.

Add three Label nodes to the HBoxContainer.

You will see that the items stack next to each other, but they don’t take up the entire space. To fix this, we will need to set their container sizing properties to fill and expand.

Now your labels will be arranged horizontally across the entire 600px by 600px boundary box!

To add some spacing between the items, select the HBoxContainer node, and change its separation constant to a value such as 10.

VBoxContainer

A VBoxContainer is used to arrange UI elements vertically. It inherits from Container and arranges its children in a vertical line.

Example Use Cases:

Vertical settings menus.
Stacked buttons.
Column-based layouts.

Mechanic:

Arrange a list of items vertically on the scene.

Implementation:

Add a Control node to your scene. This will hold our VBoxContainer. Change its size to something like 600px by 600px to give it a bounding area.

Add a VboxContainer node to this Control node. Also, make sure its anchor preset is full_rect so that it takes up the entire space provided by the Control node.

Add three Label nodes to the VBoxContainer.

You will see that the items stack on top of each other, but they don’t take up the entire space. To fix this, we will need to set their container sizing properties to fill and expand.

Now your labels will be arranged horizontally across the entire 600px by 600px boundary box!

To add some spacing between the items, select the VBoxContainer node, and change its separation constant to a value such as 10.

GridContainer

A GridContainer is used to arrange UI elements in a grid. It inherits from Container and arranges its children in a grid layout.

Example Use Cases:

Keypads.
Control panels.
Inventory grids.

Mechanic:

Arrange a list of items in a grid on the scene.

Implementation:

Add a Control node to your scene. This will hold our GridContainer. Change its size to something like 600px by 600px to give it a bounding area.

Add a GridContainer node to this Control node. Also, make sure its anchor preset is full_rect so that it takes up the entire space provided by the Control node.

Add fourLabel nodes to the GridContainer.

You will see that the items stack on top of each other, instead of in a grid. To fix this, we will need to up our columns property in our GridContainer node. Change this value to 2.

Now they are arranged in the grid, but they don’t take up the entire space. To fix this, we will need to set their container sizing properties to fill and expand.

Now your labels will be arranged in a grid format across the entire 600px by 600px boundary box!

To add some spacing between the items, select the GridContainer node, and change its separation constant to a value such as 10.

ColorRect

A ColorRect is used to display a solid color rectangle, often for backgrounds or color overlays. It inherits from Control and provides a simple way to display a rectangle filled with a specified color. The color can be set and changed dynamically.

Example Use Case:

Background overlays.
Progress bars.
Color indicators.

Mechanic:

Add a background color to your scene.

Implementation:

Add a CanvasLayer node to your scene. This will ensure that our ColorRect is drawn on our UI, so it can be displayed in the background.

Add a ColorRectnode to your CanvasLayer node.

Change its color, and change its anchor preset to be full_rect so that it takes up the entire screen.

Change the CanvasLayer node’s layer property to something like -1 so that it is displayed behind our other nodes. We should now have a background color!

Panel

A Panel is used to create a panel for grouping UI elements, providing a background and border. It inherits from Control and provides a simple way to group and visually separate UI elements.

Example Use Case:

Settings panels.
Dialog boxes.
Grouping related UI elements.

Mechanic:

Add a background color to your scene.

Implementation:

Add a CanvasLayer node to your scene. This will ensure that our Panel is drawn on our UI, so it can be displayed in the background.

Add a Panel node to your CanvasLayer node.

To change its color, we’ll need to give it a new theme style of type StyleBoxFlat.

Now we can give it a new color, border, and even a shadow!

Change its anchor preset to full_rect so that it takes up the entire screen.

Change the CanvasLayer node’s layer property to something like -1 so that it is displayed behind our other nodes. We should now have a background color!

CanvasModulate

A CanvasModulate applies a color tint to all nodes on a canvas. It tints the canvas elements using its assigned color.

Example Use Cases:

Night mode effect.
Global color adjustments.
Visual effects for different game states.

Mechanic:

Add a day-and-night cycle to your game

Implementation:

Add a CanvasModulatenode to your scene.

If you change its color property, the entire scene's color should change.

We want to animate this property. So, add an AnimationPlayer node to your scene.

Create a new animation called day_night_cycle. Set the length of this animation to be 24 seconds long. This will make our day 24 seconds long (for 24 hours).

Also, enable looping.

Now add a color keyframe for every 6 hours (or whatever preference you have). These colors should represent the colors from 0 AM to 24 PM.
On my timeline, my colors are:
0: #0f0a49
6: #7b5436
12: #ffffff
18: #5b6a99
24: #0f0a49

Now when we run our game, we should play this animation.

### Main.gd

extends Node2D

@onready var animation_player = $AnimationPlayer

func _ready():
 animation_player.play("day_night_cycle")

If you want a better tutorial using shaders, check out the video on my YouTube channel!

Button

A Button is used to create a clickable button for user interactions. It inherits from BaseButton and provides functionality for detecting clicks and triggering actions.

If you want to use a button that has a texture (image) and more customizability, you should use a TextureButton node. The TextureButton node is a button that uses textures for its different states (normal, pressed, hover, etc.) instead of the default theme. This allows for more customized and visually appealing buttons. It inherits from BaseButton and provides properties to set textures for different states.

Example Use Cases:

Interactive buttons.
Menu options.
Form submissions.

Mechanic:

Add a clickable button to your scene.

Implementation:

Add a CanvasLayer node to your scene. This will ensure that our Buttonis drawn on our UI, so it can be displayed at all times.
Add a Button node to your CanvasLayer node.

If you run your scene, your Button should be visible.

Now, attach its pressed() signal function to your script.

If we press the button, we will change its text. We will keep track of the times we’ve pressed it and update it each time we press the button.

### Main.gd

extends Node2D

@onready var button = $CanvasLayer/Button

var button_pressed_count = 0

func _on_button_pressed():
 button_pressed_count += 1
 button.text = "You've pressed me: " + str(button_pressed_count) + " times!"

Every time you press the button, the count should update!

Label

A Label is used to display text. It inherits from Control and provides functionality for displaying text.

Example Use Cases:

Static text display.
Descriptive labels.
Titles and headings.

Mechanic:

Add a label that changes its text when you hover over it.

Implementation:

Add a CanvasLayer node to your scene. This will ensure that our Label is drawn on our UI, so it can be displayed at all times.
Add a Labelnode to your CanvasLayer node.

If you run your scene, your Label should be visible.

Now, let’s make it more visible. Change its font color to be red, and its size to something like 25px.

Since we want it to detect mouse events, we need to change its Mouse Filtermode to Pass.

Now, to detect that we are hovering over it, we need to attach its mouse_entered() and mouse_exited() signals to our script.

Then, simply change the text when we enter and exit the label while hovering! If you run your game, the label should change depending on whether or not you are hovering over it.

### Main.gd

extends Node2D

@onready var label = $CanvasLayer/Label


func _on_label_mouse_entered():
 label.text = "You're hovering over a label"


func _on_label_mouse_exited():
 label.text = "You're away from the label"

RichTextLabel

A RichTextLabel is used to display formatted text. It inherits from Control and provides functionality for displaying rich text with formatting, such as bold, italics, and images.

Example Use Cases:

Formatted text display.
Dialogue boxes.
Instructional text.

Mechanic:

Write words in a typewriter effect.

Implementation:

Add a CanvasLayer node to your scene. This will ensure that our RichTextLabelis drawn on our UI, so it can be displayed at all times.
Add a RichTextLabel node to your CanvasLayer node.

Change its size to something like 200px by 200px.

If you run your scene, your RichTextLabel should be visible.

Now, let’s make it more visible. Change its font color to red, and its size to something like 25px.

To create our typewriter animation, we will need to use an AnimationPlayer node. Add this node to your scene.

Create a new animation called typewriter.

To create a typewriter effect, we need to animate our RichTextLabel node’s visible ratio property, which defines how much of our text is visible.

At the 0 keyframe mark, set your visible ratio to be equal to 0.

At the 1 keyframe mark, set your visible ratio to be equal to 1. This means in 1 second, our text will go from no characters to full characters.

Now if you play your animation, your text should play as if it's being typed out.

ProgressBar

ProgressBar is a UI element that visually represents a value within a range. It inherits from the Range class, which provides properties like min_value, max_value, and value to control the progress.

Example Use Cases:

Loading screens.
Health bars.
Progress indicators.

Mechanic:

Create a health bar that increases every 1 second, and when we press SPACE, it decreases in value.

Implementation:

Add a CanvasLayer node to your scene. This will ensure that our ProgressBar node is drawn on our UI, so it can be displayed at all times.
Add a ProgressBarnode to your CanvasLayer node.

Change its size to something like 200px by 27px, and enable its Rounded value so it only shows whole numbers.

To be able to increase our ProgressBar, we should add a Timer node. Enable this timer node’s autostart property, and connect its timeout signal to your script.

Whenever it times out (every 1 second its active), we will increase our “health” value.

### Main.gd

extends Node2D

@onready var progress_bar = $CanvasLayer/ProgressBar

func _on_timer_timeout():
 progress_bar.value += 1

Whenever we press our SPACE bar, we should decrease our health value.

### Main.gd

extends Node2D

@onready var progress_bar = $CanvasLayer/ProgressBar

func _on_timer_timeout():
 progress_bar.value += 1

func _input(event):
 if event.is_action_pressed("ui_accept"):
  progress_bar.value -= 5

Now if we run our scene, our health should increase every second, but decrease when we press our button.

The Book of Nodes

Christine Coomans — Wed, 07 Aug 2024 12:43:23 GMT

If you’ve ever delved into the Godot Documentation, you likely noticed two things: first, there is an abundance of nodes (many of which you might never use), and second, some of these nodes can be quite confusing.

As a beginner Godot developer, understanding the purpose of each node can be confusing. Even as a somewhat seasoned Godot creator, I am still learning about new nodes and methods of doing things to this day. For example, when I first started learning Godot, I used a ColorRect node for all my UI backgrounds. However, this meant that if I wanted a background with a border, I had to use multiple ColorRects to achieve this.

Figure 1: Using ColorRects to create a box with a border and a shadow.

Later on, I discovered the Panel node, which offers a lot more customization, built-in borders, and even rounded corners! Although I still use ColorRects, I now know that there are better nodes (like the Panel node) that I can use to achieve the same result.

Figure 2: Using a Panel to create a box with a border, curved corners, and a shadow.

That’s why I wanted to create an encyclopedia of sorts, focusing on the most essential nodes to know as a beginner.

Now, to complete this encyclopedia, I’ve decided to organize the content into three distinct categories: 2D, 3D, and UI. Within each category, you’ll find a list of nodes relevant to that section. For each node, I will cover the mechanics that can be implemented using this node, along with basic examples of how this mechanic can be implemented into a project. This ensures that you not only learn about each node’s functionality but also how they can be practically applied during your game development process.

Before we begin, if you need a base project to test these code snippets, feel free to download my FREE 2D and 3D templates here. I’ll be using these templates throughout this post.

*Please note that this list is not 100% complete yet, but I will be updating this list as time goes on.

UPDATE:

Get your copy of My Book of Nodes for Godot 4 in an offline PDF format (and Word for GIF previews) now!

In the offline version, all the categories (2D, 3D, and UI) are combined in a single document. No more waiting for my websites and blogs to load — take the content with you and access it instantly, wherever you are.

Check it out, it’s free. 😊

https://ko-fi.com/s/e9f19e30ff

Godot 2D & 3D Prototype Templates

Christine Coomans — Mon, 05 Aug 2024 12:21:23 GMT

I have created templates for my Godot 2D and 3D projects on YouTube and KoFi. These templates are designed for prototyping and developing systems in Godot. They make it easier for us because we no longer have to build everything from scratch! 😊

The 2D template contains a basic top-down character and a map, and the entire project template was created by me with the help of the following assets:

The 3D template contains a basic third-person character and a map, and the entire project was created by me with the help of the following assets:

3D Preview:

2D Preview:

You can download these projects for free on my KoFi page. They are not available on GitHub because the file size was too large to upload. You don’t need to pay to use them!

➡️Download Templates

Try Hack Me: Friday Overtime Complete Write-up

Christine Coomans — Fri, 26 Jul 2024 11:15:34 GMT

In my most recent side-quest in life, I decided to dive back into the world of hAcK1_nG. The last time I was dabbling in the art of Cybersecurity, I focused more on red-teaming, but this time my interest is peaked by the life of a blue-teamer.

That’s right, I’m joining The Defenders (trademark coming soon). But before I do that, let’s have a look at completing the Friday Overtime room.

So in this scenario, we are the only remaining CTI Analyst working overtime at PandaProbe Intelligence. We need to investigate potential file attachment breaches that are suspected to contain malware samples.

Let’s start by running our machine. This might take a few minutes, so wait until your machine IP is populated.

After your machine is up and running, let’s start answering our questions.

1. Who shared the malware samples?

On the machine, open up Chromium and navigate to your given IP Address. At the top of the CentOS screen is an option to “Log in — DocIntel”. Click on it and log in with the given credentials.

From there on you will be greeted by your email, which contains the information on the breach as well as the document containing the files, and the password to the document.

If you scroll down, you will see the name of the person who shared the malware sample files.

2. What is the SHA1 hash of the file “pRsm.dll” inside samples.zip?

To find this out, we will need to first download the actual attachment and extract the files from it. Click on the attatchment on the right to download the file called “sample.zip”.

Now, you can either extract this zipped folder in the Command Line, or just by right-clicking it and extracting it manually. Remember, the password to this file is Panda321!, so enter that when prompted.

Let’s open up our Terminal so that we can read the SHA1 hash of the file “pRsm.dll”.

To read the hash of our file, we will make use of sha1sum. SHA1sum is a utility that computes and verifies SHA-1 cryptographic hash values. The primary reason you can use SHA1sum to read the hash of our.dll file — or any file, for that matter — is due to its ability to process binary data and generate a fixed-size hash value, which is a representation of the file’s content.

3. Which malware framework utilizes these DLLs as add-on modules?

For this question, I turned to good old Google to see if I could find any information on “pRsm.dll” and the framework used.

I saw it flagged in this article, so I clicked on it and searched for “framework”. Without too much effort, you can find the answer in the second paragraph of the article.

4. Which MITRE ATT&CK Technique is linked to using pRsm.dll in this malware framework?

For this, we need to search “pRsm.dll” and look out for a Technique ID (TXXXX), since we see that the answer required has 5 characters.

5. What is the CyberChef defanged URL of the malicious download location first seen on 2020–11–02?

Now we need to find a URL connected to 2020–11–02, and defang it on CyberChef. Defanging URLs and IPs is a critical practice for safely sharing potentially harmful links, and CyberChef simplifies this process, especially when handling large volumes of data. This practice is essential when sharing resources that might contain harmful data.

Let’s head back to our article, and search for our date “2020–11–02”. We can see that it lands on a result that has a URL attached to it.

Copy and paste this URL into the CyberChef input, and add the recipe “Defang URL”. The output will give you your answer.

6. What is the CyberChef defanged IP address of the C&C server first detected on 2020–09–14 using these modules?

For this, we also need to search our date on the article we sourced previously. The IP should correlate to the date first seen on “2020–09–14”.

Let’s copy this IP into the CyberChef input (remove the brackets because it should be pure data). Change the recipe to “Defang IP”. The result should be your answer.

7. What is the SHA1 hash of the spyagent family spyware hosted on the same IP targeting Android devices on November 16, 2022?

Unfortunately, we cannot find the SHA1 hash of the malware on the article that we’ve been using. But, luckily for us, we can make use of a service that analyzes files and URLs for viruses, worms, trojans, and other kinds of malicious content detected by antivirus engines and website scanners.

Can you think of a service that can do all of the above? Well, we can use VirusTotal. VirusTotal will allow us to search for the malware connected to the IP address, and analyze all of its characteristics. So let’s open up the site and search for any data connected to our “fanged” IP address.

Click on the “Relations” panel to see where this IP has been flagged. This panel helps us explore the relationships between various indicators of compromise (IoCs) such as files, URLs, domains, and IP addresses.

You will see that an IoC from this IP was picked up on Android on the date of 2022–11–16. This is the name of our spyagent family spyware.

Now all we need is the hash value of this spyagent. Copy the name and search it. If we click on the “Details” of our result, we will see that there is a SHA1 hash value, which is what we need for our final flag!

Conclusion

Congratulations on completing the room. I hope you found the writeup valuable, and that you could follow along with ease.

Now, onwards to the next room! 😊

Android: How to Install ADB, APK’s, and JADX-GUI on Parrot OS

Christine Coomans — Wed, 24 Jul 2024 20:15:50 GMT

Recently I have dived into the journey of learning how to hack, or more precisely pen-testing. Since I focused previously on Android Pentesting when I explained how to install Genymotion and VirtualBox on Parrot OS, I thought, why don’t I write another tutorial on how to install ADB and JADX-GUI on Parrot OS as it is related and quite easy to do. This tutorial assumes you have Android Studio and Parrot OS installed. A good Android Studio installation tutorial can be found here.

In case you wonder, the version I use of Parrot is the Security Edition, which comes with most tools installed.🤠

First, let’s go over ADB and JADX-GUI. Android Debug Bridge (ADB) is a command-line tool that lets us communicate with a device, but more importantly for this tutorial, install APKs onto our emulated device. JADX-GUI is at its core a code decompiler, so we can take our APK that we downloaded and pop it into the decompiler and voila, we can see all the source code that it contains!

Installing ADB & APK’s

Once you have started up your Parrot OS system, open up a terminal using CTRL + ALT + T and run the following command: sudo apt-get update.

Then we can install adb with the following command sudo apt-get install android-tools-adb.

Once it has been installed, we can check if it “worked” by opening Genymotion and running our installed device. Check my previous tutorial on how to do this. Once your emulated device is up and running, we can go back to our terminal and type in adb devices. We can see that we get a list of devices that are attached, one of which is our emulated device.

From there on, we need to install an APK to install onto our device. An APK put simply, is a packaged app that we can download and install for testing purposes. Twelve-year-old me would be so shocked to know that that is how my friend copied their GTA San Andreas game onto my phone!😶

The APK that we will download in this tutorial is the Diva APK. You can download the APK here. Once you have downloaded it, head over to your Downloads folder and extract it by right-clicking and saying extract here.

Finally, we can download our apk. Head back into your terminal, making sure you are in the directory of your APK and that you have extracted the DIVA file. Type in the following command: adb install diva-beta.apk.

Good job! When we head back to our emulated device we can see that our app is now installed onto our device.😄

Installing JADX-GUI

Now that we have our ADB and APK installed, we can now use this APK in JADX-GUI to decompile the code. ADB allowed us to access the app. JADX-GUI will allow us to access the app’s code.

To install JADX-GUI, we can simply do the following in the terminal:

sudo apt-get install jadx
git clone https://github.com/skylot/jadx.git
cd jadx
./gradlew dist

Then, we can go over to where we downloaded it, go into jadx > build > jadx > bin, and double click on JADX-GUI. Select the option to run it in the terminal.

If that does not work for you, you can cd into the jadx directory, and run the jadx-gui command directly.

It works! Now we can select our Diva APK that we extracted and pop it into the window that just opened. We can see that we can now access most of the source code of the app.

BONUS: JADX-GUI Bash Script

To have to go to the directory where JADX-GUI is every time we want to open/use it is tedious, and time-wasting. Thus we can create a quick bash script to save on our desktop to quickly run it when needed. In Pluma, type in the following:

#!/bin/bash

cd /home/yourname/Downloads/jadx/build/jadx/bin && ./jadx-gui

Or if you had to follow the second execution step (running jadx-gui directly), you will need to type the following:

#!/bin/bash

cd /home/yourname/Downloads/jadx && jadx-gui

Save this file as whatever, like run_jdx_gui. Save it in the directory of your desktop (or wherever you save your bash scripts), and then you can open up a new terminal and cd into the directory where run_jdx_gui is stored.

Run the following command: chmod +x run_jdx_gui. Now when you click on the script it (or run it in the terminal via ./run_jdx-gui) will open up the terminal and run the app!

That’s it for now, I hope this made sense. Let me know if you need help. See ya next time!

(You can see this post on my GitHub and pull it for future use❤️)