6. Collectibles

Implementeer munten met Area3D en track score met signals en groups

Overzicht

In dit hoofdstuk voeg je collectibles toe aan je platformer - munten die de player kan verzamelen. Je implementeert:

• Coin scene met Area3D voor collision detection

• Score tracking met signals en groups

• ScoreManager als autoload singleton

Coin scene maken

Begin met een simpele coin-scene die je later kunt oprapen.

1. Ga naar Scene > New Scene

2. Selecteer Other Node en zoek naar Area3D

3. Klik Create

4. Hernoem de root node naar Coin

5. Sla de scene op als res://objects/Coin.tscn

Coin model toevoegen

Voeg nu het coin-model toe.

1. Open het FileSystem panel

2. Navigeer naar models/coin.glb en Sleep coin.glb naar de Coin root node in de Scene hierarchy

3. Het model wordt nu als child toegevoegd

Scene hierarchy:

Coin (area3d)
└── coin (imported scene from coin.glb)

CollisionShape3D Toevoegen

Elke physics body heeft een collision shape nodig.

1. Selecteer de Coin root node

2. Rechts-klik > Add Child Node > CollisionShape3D

3. In de Inspector van CollisionShape3D:

   • Shape > New SphereShape3D

4. Pas de SphereShape3D aan zodat deze het coin model bedekt:

5. Sla de scene op

Scene hierarchy (updated):

Coin (Area3D)
├── coin (imported scene)
└── CollisionShape3D (BoxShape3D)

Plaats de coin in de level

Voeg de coin toe aan de level om te testen.

1. Open scenes/main.tscn

2. Ga naar het File System venster, en sleep objects/coin.tscn in de scene

3. Positioneer de coin ergens in de level waar de player er aan kan

Coin script toevoegen

Schrijf nu een script dat detecteert wanneer de player de coin raakt.

1. Open objects/coin.tscn

2. Selecteer de Coin root node

3. Klik op Attach Script

   • Language: C#

   • Template: Empty

   • Class Name: Coin

   • Path: res://scripts/Coin.cs

4. Klik Create

5. Godot maakt gebruik van een template script met een lege _Process en _Ready method. Deze methods hebben we voorlopig niet nodig, dus mag je ze verwijderen.

6. Voeg een lege OnBodyEntered() method toe:

using Godot;

public partial class Coin : Area3D
{
    private void OnBodyEntered(Node3D body)
    {
        GD.Print("Coin picked up!");
    }
}

BodyEntered Signal Verbinden

Verbind het BodyEntered-signaal van de Area3D aan je OnBodyEntered()-methode via de UI.

1. In objects/Coin.tscn, selecteer de root (Area3D) node

2. Ga naar het Node tabblad in de Inspector (naast de Inspector tab)

3. Dubbelklik op het body_entered(body: Node3D) signal

4. In het "Connect a Signal" venster:

   • Receiver Method: OnBodyEntered (type dit in)

   • Zorg dat Coin geselecteerd is (de node met het script) als receiver node

5. Klik Connect En pas de signature van OnBodyEntered() aan naar:

private void OnBodyEntered(Node3D body)
{
    GD.Print($"Coin touched by: {body.Name}");
}

Test de signal connection

Test eerst of de signal correct verbonden is.

1. Test met F5:

   • Spring of loop doorheen de coin

   • Check de Output console (onderaan in Godot)

   • Zie je "Coin touched by: Player!" in de console?

Coin verzamelen

Wanneer de Coin wordt geraakt, moeten er een aantal zaken gebeuren.

• de coin moet verdwijnen

• een signal moet verstuurd worden dat er een punt verzameld is

• dit mag enkel gebeuren als het de speler is die de coin aanraakt

1. Check eerst of de parameter body van het type Player is, zodat de Coin alleen reageert op de player (en niet op enemies of andere objects)

using Godot;

public partial class Coin : Area3D
{
    private void OnBodyEntered(Node3D body)
    {
        // Check of het de player is
        if (body is Player)
        {
        }
    }
}

1. QueueFree() markeert de node voor verwijdering aan het eind van het frame

using Godot;

public partial class Coin : Area3D
{
    private void OnBodyEntered(Node3D body)
    {
        // Check of het de player is
        if (body is Player)
        {
            QueueFree(); // Verwijder de coin uit de scene
        }
    }
}

ScoreManager

In plaats van een ScoreManager node in elke scene te plaatsen, maak je het een autoload. Dit betekent dat ScoreManager automatisch beschikbaar is in het hele spel, en de score blijft behouden zelfs als je van scene wisselt.

1. Maak een nieuw C# script in de scripts folder:

   • Rechts-klik op de scripts folder in FileSystem

   • Create New > Script

   • Path: scripts/ScoreManager.cs

   • Template: Empty

   • Klik Create

2. Open scripts/ScoreManager.cs en voeg de basis code toe:

using Godot;

public partial class ScoreManager : Node
{
    private int _score = 0;
}

1. Registreer ScoreManager als autoload:

   • Ga naar Project > Project Settings

   • Klik op het Globals tab (of Autoload)

   • Bij Path: Klik op het folder icon en selecteer scripts/ScoreManager.cs

   • Bij Node Name: Type ScoreManager (dit is de naam waarmee je het overal kan aanroepen)

   • Klik Add

   • Klik Close

Score tracking - signals

Wanneer een Coin wordt verzameld, wil je dat die coin een signaal uitstuurt waar de ScoreManager naar kan luisteren.

1. Open het Coin script

2. Voeg een Signal toe aan het Coin script.

using Godot;

public partial class Coin : Area3D
{
    [Signal]
    public delegate void CollectedEventHandler();

    // ... rest van de code
}

1. Roep EmitSignal() aan wanneer de coin verzameld wordt:

using Godot;

public partial class Coin : Area3D
{
    [Signal]
    public delegate void CollectedEventHandler();

    private void OnBodyEntered(Node3D body)
    {
        if (body is Player)
        {
            // Emit signal
            EmitSignal(SignalName.Collected);

            GD.Print("Coin collected!");
            QueueFree();
        }
    }
}

Coin group

Nu moet je alle coins vinden in de level om te luisteren naar hun Signals. Groups zijn een Godot feature om nodes te organiseren. Door alle Coins in één group te plaatsen, kan de ScoreManager gemakkelijk alle Coins vinden.

1. Open objects/Coin.tscn

2. Selecteer de Coin root node

3. In het Node venster rechtsboven (naast Inspector), klik de Groups tab

4. Klik op het + icoontje (Add a new group)

5. Typ coins in het veld

6. Vink Global aan, zodat we de group overal kunnen terugvinden

7. Klik Add

8. Sla op - nu zit elke Coin instance automatisch in de "coins" group

ScoreManager Logic

De scoreManager moet reageren wanneer een Coin een signaal uitstuurt dat die is verzameld. Om dat te kunnen doen, moet de scoreManager aan begin van het spel alle coins in de level vinden, en vervolgens een functie koppelen aan het collected Signal van elke Coin.

1. Voeg de _Ready method terug toe aan de ScoreManager klasse.

using Godot;

public partial class ScoreManager : Node
{
    private int _score = 0;

    public override void _Ready()
    {
    }
}

1. Voeg een OnCoinCollected method toe aan de ScoreManager, waarin de score wordt verhoogt met 1

    private void OnCoinCollected()
    {
        _score += 1;
        GD.Print($"Score: {_score}");
    }

1. Gebruik GetTree().GetNodesInGroup() om alle nodes in een group op te halen.

using Godot;

public partial class ScoreManager : Node
{
    private int _score = 0;

    public override void _Ready()
    {
        // Vind alle coins in de scene
        var coins = GetTree().GetNodesInGroup("coins");

        GD.Print($"Found {coins.Count} coins in the level");
    }
    
    // ... rest van de code
}

1. Loop door alle coins en subscribe op hun Collected signal. In plaats van dit te doen via de Godot Editor, doen we het ditmaal met code. Met behulp van signalname += methodname verbind je een method (methodname) aan een signal (signalname). Let daarbij op dat je géén haakjes gebruikt bij de methodname!

using Godot;

public partial class ScoreManager : Node
{
    private int _score = 0;

    public override void _Ready()
    {
        // Vind alle coins in de scene
        var coins = GetTree().GetNodesInGroup("coins");

        // Subscribe op elk coin's Collected signal
        foreach (Node coin in coins)
        {
            if (coin is Coin coinNode)
            {
                coinNode.Collected += OnCoinCollected;
            }
        }

        GD.Print($"Subscribed to {coins.Count} coins");
    }

    private void OnCoinCollected()
    {
        _score += 1;
        GD.Print($"Score: {_score}");
    }
}

Meerdere coins toevoegen

1. Open scenes/main.tscn

2. Duplicate de bestaande Coin node (Ctrl+D of rechts-klik > Duplicate)

3. Positioneer coins verspreid over de level

4. Maak 5-8 coins zodat je score tracking goed kan testen

5. Sla de scene op

Test score tracking

1. Run het spel (F5)

2. Check de Output panel onderaan - je ziet "Subscribed to X coins"

3. Verzamel coins

4. Je ziet nu:

Score: 1
Score: 2
Score: 3
...

Complete scripts

Klik hier voor de volledige Coin.cs en ScoreManager.cs scripts

Coin.cs

using Godot;

public partial class Coin : Area3D
{
    [Signal]
    public delegate void CollectedEventHandler();

    private void OnBodyEntered(Node3D body)
    {
        if (body is Player)
        {
            EmitSignal(SignalName.Collected);

            GD.Print("Coin collected!");
            QueueFree();
        }
    }
}

ScoreManager.cs

using Godot;

public partial class ScoreManager : Node
{
    private int _score = 0;

    public override void _Ready()
    {
        // Vind alle coins in de scene
        var coins = GetTree().GetNodesInGroup("coins");

        // Subscribe op elk coin's Collected signal
        foreach (Node coin in coins)
        {
            if (coin is Coin coinNode)
            {
                coinNode.Collected += OnCoinCollected;
            }
        }

        GD.Print($"Subscribed to {coins.Count} coins");
    }

    private void OnCoinCollected()
    {
        _score += 1;
        GD.Print($"Score: {_score}");
    }
}