11. Car Pathfinding & Spawning

Implementeer car pathfinding met NavigationAgent3D en auto-spawning systeem

Overzicht

In dit hoofdstuk leer je:

• Car.cs (CharacterBody3D) met NavigationAgent3D

• Pathfinding met GetNextPathPosition()

• Smooth rotation met Basis.Slerp()

• Path length calculation via PathChanged signal

• Money rewards bij bestemming

• CarSpawner.cs timer-based spawning

• Random building selection voor routes

• Spawn position calculation (adjacent roads)

Wat is een NavigationAgent?

Een NavigationAgent3D is een node die pathfinding automatiseert. Je geeft een target positie en de agent:

1. Berekent het kortste pad via de NavigationMesh

2. Geeft waypoints terug langs het pad

3. Detecteert wanneer de destination is bereikt

In dit hoofdstuk:

• Maak een Car scene met NavigationAgent3D

• Implementeer movement door waypoints te volgen

• Roteer smooth naar de bewegingsrichting

• Bereken path length voor revenue

• Maak een CarSpawner die automatisch cars spawnt tussen random buildings

• Verdien geld wanneer cars hun bestemming bereiken

Complete gameplay loop: Player places buildings/roads → CarSpawner spawns cars → Cars navigate and earn money → Player builds more infrastructure

Car script aanmaken

Maak een nieuwe script voor het voertuig.

Nieuwe Godot-specifieke elementen:

• NavigationAgent3D - Agent voor 3D pathfinding

• CharacterBody3D - Physics body voor characters/vehicles

• Basis - 3D rotation matrix

• Slerp() - Spherical linear interpolation voor smooth rotatie

1. Maak een nieuw script scripts/Car.cs

2. Maak de class aan die inherit van CharacterBody3D:

using Godot;

public partial class Car : CharacterBody3D
{
}

1. Voeg exports toe voor configuratie:

public partial class Car : CharacterBody3D
{
    [Export] float Speed { get; set; } = 3.0f;
    [Export] float RotationSpeed { get; set; } = 10.0f;
    [Export] int MoneyPerUnit { get; set; } = 10;
    [Export] private NavigationAgent3D _navigationAgent;
}

Exports uitgelegd:

• Speed - Hoe snel de car beweegt (units per seconde)

• RotationSpeed - Hoe snel de car draait (multiplier voor slerp)

• MoneyPerUnit - Hoeveel geld per tile traveled (economy)

• _navigationAgent - Reference naar de NavigationAgent3D child node

1. Voeg een field toe voor path length tracking:

    [Export] private NavigationAgent3D _navigationAgent;

    private int _pathLength = 0;
}

1. Sla het script op

SetTargetPosition method

Maak een method om de destination in te stellen.

Nieuwe Godot-specifieke elementen:

• TargetPosition - De destination voor pathfinding

1. Voeg een lege SetTargetPosition() method toe:

    private int _pathLength = 0;

    public void SetTargetPosition(Vector3 target)
    {
    }
}

1. Zet de target positie. De NavigationAgent berekent automatisch het pad:

    public void SetTargetPosition(Vector3 target)
    {
        _navigationAgent.TargetPosition = target;
    }

Wat gebeurt er intern?

• NavigationAgent zoekt naar de dichtstbijzijnde NavigationMesh polygon

• A* pathfinding algoritme berekent kortste route

• PathChanged signal wordt gefired wanneer het pad klaar is

1. Sla het script op

CalculatePathLength implementeren

Maak een method om de afgelegde afstand te berekenen (voor revenue).

Nieuwe Godot-specifieke elementen:

• GetCurrentNavigationPath() - Array van waypoints langs het pad

• PathChanged - Signal dat fired wanneer een nieuw pad is berekend

1. Voeg een lege CalculatePathLength() method toe:

    }

    private void CalculatePathLength()
    {
    }
}

1. Haal het pad op:

    private void CalculatePathLength()
    {
        var path = _navigationAgent.GetCurrentNavigationPath();
    }

1. Check of het pad geldig is. Een pad met minder dan 2 punten is onbruikbaar:

    private void CalculatePathLength()
    {
        var path = _navigationAgent.GetCurrentNavigationPath();
        if (path.Length < 2) return;
    }

Waarom < 2?

• 0 waypoints = geen pad gevonden

• 1 waypoint = alleen start positie, geen movement

• 2+ waypoints = geldig pad (start → destination)

1. Bereken path length. Elk waypoint is ongeveer 1 grid tile:

        if (path.Length < 2) return;

        _pathLength = path.Length - 1;
    }

Waarom -1?

• path.Length telt ook de start positie

• We willen alleen traveled tiles tellen

• Start → waypoint 1 → waypoint 2 = 2 tiles traveled, maar 3 waypoints

1. Debug print (tijdelijk, om te testen):

        _pathLength = path.Length - 1;
        GD.Print(_pathLength);
    }

1. Disconnect de signal. We hoeven path length maar 1x te berekenen:

        GD.Print(_pathLength);

        _navigationAgent.PathChanged -= CalculatePathLength;
    }

Waarom disconnecten?

• PathChanged kan meerdere keren firen (rerouting)

• We willen alleen het originele pad tellen

• Voorkomt memory leaks (event handlers blijven anders actief)

1. Sla het script op

_Ready implementeren

Koppel de PathChanged signal aan CalculatePathLength.

1. Voeg een lege _Ready() method toe:

    private int _pathLength = 0;

    public override void _Ready()
    {
    }

    public void SetTargetPosition(Vector3 target)

1. Connect de PathChanged signal:

    public override void _Ready()
    {
        _navigationAgent.PathChanged += CalculatePathLength;
    }

Signal flow:

1. SetTargetPosition() wordt aangeroepen

2. NavigationAgent berekent pad (asynchroon)

3. PathChanged signal fired

4. CalculatePathLength() wordt aangeroepen

5. _pathLength wordt ingesteld

6. Sla het script op

_PhysicsProcess implementeren - Destination check

Implementeer de movement loop. Start met destination checking.

1. Voeg een lege _PhysicsProcess() method toe:

    }

    public override void _PhysicsProcess(double delta)
    {
    }
}

1. Check of we de destination hebben bereikt:

    public override void _PhysicsProcess(double delta)
    {
        if (_navigationAgent.IsNavigationFinished())
        {
        }
    }

IsNavigationFinished:

• true wanneer de car binnen de target radius is

• Default radius = 0.5 units

• Voorkomt "orbiting" rondom het target

1. Bereken money earned:

        if (_navigationAgent.IsNavigationFinished())
        {
            int moneyEarned = _pathLength * MoneyPerUnit;
        }

1. Voeg het geld toe aan de MoneyManager:

        if (_navigationAgent.IsNavigationFinished())
        {
            int moneyEarned = _pathLength * MoneyPerUnit;
            GetNode<MoneyManager>("/root/MoneyManager").AddMoney(moneyEarned);
        }

Singleton access:

• /root/MoneyManager = AutoLoad node (hoofdstuk 9)

• GetNode<MoneyManager>() = type-safe node lookup

• AddMoney() = method uit hoofdstuk 9

1. Despawn de car:

            GetNode<MoneyManager>("/root/MoneyManager").AddMoney(moneyEarned);

            QueueFree();
            return;
        }

QueueFree:

• Verwijdert de node aan het einde van het frame

• Veiliger dan Free() (voorkomt crashes tijdens callbacks)

1. Sla het script op

_PhysicsProcess implementeren - Movement

Voeg movement toe door waypoints te volgen.

Nieuwe Godot-specifieke elementen:

• GetNextPathPosition() - Volgende waypoint in het pad

• MoveAndSlide() - Beweeg met collision detection

1. Haal de volgende waypoint op:

            return;
        }

        Vector3 nextPosition = _navigationAgent.GetNextPathPosition();
    }

1. Bereken de richting naar de waypoint:

        Vector3 nextPosition = _navigationAgent.GetNextPathPosition();
        Vector3 direction = (nextPosition - GlobalPosition).Normalized();
    }

Direction berekening:

• nextPosition - GlobalPosition = offset vector

• .Normalized() = lengte 1 behouden, alleen richting

• Bijvoorbeeld: (3, 0, 4) → (0.6, 0, 0.8)

1. Zet de velocity:

        Vector3 direction = (nextPosition - GlobalPosition).Normalized();

        Velocity = direction * Speed;
    }

Velocity:

• CharacterBody3D.Velocity bepaalt bewegingsrichting

• MoveAndSlide() gebruikt deze property

• Direction * Speed = snelheid in die richting

1. Roep MoveAndSlide aan:

        Velocity = direction * Speed;

        MoveAndSlide();
    }

1. Sla het script op

_PhysicsProcess implementeren - Rotation

Voeg smooth rotatie toe zodat de car naar de bewegingsrichting kijkt.

Nieuwe C#-specifieke elementen:

• Basis.LookingAt() - Creëert rotatie matrix die naar een richting kijkt

• Basis.Slerp() - Smooth interpolatie tussen twee rotaties

1. Maak een look direction. Negeer de Y component om alleen horizontale rotatie te hebben:

        Velocity = direction * Speed;

        Vector3 lookDirection = new Vector3(direction.X, 0, direction.Z);

        MoveAndSlide();

Waarom Y = 0?

• Cars moeten horizontaal draaien, niet kantelen

• direction kan een Y component hebben (heuvel op/af)

• lookDirection heeft alleen X en Z voor yaw rotatie

1. Bereken de target rotation:

        Vector3 lookDirection = new Vector3(direction.X, 0, direction.Z);
        Basis targetBasis = Basis.LookingAt(lookDirection, Vector3.Up);

        MoveAndSlide();

Basis.LookingAt:

• Eerste parameter = forward direction (-Z richting in Godot)

• Tweede parameter = up vector (meestal Vector3.Up)

• Return value = rotation matrix

1. Interpoleer smooth naar de target rotation:

        Basis targetBasis = Basis.LookingAt(lookDirection, Vector3.Up);
        Basis = Basis.Slerp(targetBasis, RotationSpeed * (float)delta);

        MoveAndSlide();

Slerp parameters:

• Basis = huidige rotatie

• targetBasis = gewenste rotatie

• RotationSpeed * delta = interpolation factor (0-1)

• Hogere RotationSpeed = snellere draai

Waarom Slerp?

• Lineaire interpolatie (Lerp) werkt niet goed voor rotaties

• Slerp behoudt "spherical" motion (constante hoeksnelheid)

• Voorkomt gimbal lock

1. Sla het script op

Car scene opzetten

Bouw de Car scene met mesh, collision, en navigation.

1. Maak een nieuwe scene: Scene → New Scene

2. Gebruik een CharacterBody3D als root node

3. Hernoem naar Car

4. Selecteer Car in de Scene Tree

5. Klik en sleep één van de auto's vanuit het File venster naar je scene

6. Verklein de auto tot een schaal van 0.2

7. Voeg een CollisionShape3D toe als child van Car

8. Selecteer CollisionShape3D

9. In de Inspector → Shape: kies New BoxShape3D

10. Klik op de BoxShape3D resource

11. Pas de size aan zodat die ongeveer overeenkomt met de auto

12. Plaats nu je auto wat meer naar rechts! Zo zal de auto aan de rechterkant van de baan rijden. Vergeet niet om je Collision ook te verplaatsen.

13. Voeg een NavigationAgent3D toe als child van Car

14. Hernoem naar NavigationAgent

15. Selecteer NavigationAgent

16. In de Inspector → NavigationAgent3D:

    • Target Desired Distance: 0.5 (stop 0.5 units voor target)

    • Path Desired Distance: 0.1 (waypoint bereikt bij 0.1 units)

17. Selecteer Car (root node)

18. In de Inspector → Car script sectie:

    • Sleep NavigationAgent naar de Navigation Agent export

19. Sla de scene op als scenes/Car.tscn (Ctrl+S)

CarSpawner script aanmaken

Maak een script die automatisch cars spawnt.

Nieuwe Godot-specifieke elementen:

• PackedScene - Scene resource die geïnstantieerd kan worden

• Instantiate<T>() - Creëert een instance van de scene

• Timer - Node voor interval-based events

1. Maak een nieuw script scripts/CarSpawner.cs

2. Maak de class aan die inherit van Node:

using Godot;
using System;
using System.Collections.Generic;
using System.Linq;

public partial class CarSpawner : Node
{
}

1. Voeg exports toe:

public partial class CarSpawner : Node
{
    [Export] public PackedScene CarScene { get; set; }
    [Export] public GridMap GridMap { get; set; }
    [Export] public float SpawnInterval { get; set; } = 5.0f;
}

Exports:

• CarScene - Reference naar Car.tscn (drag & drop in Inspector)

• GridMap - Reference om buildings/roads te vinden

• SpawnInterval - Seconden tussen spawns (5 = elke 5 seconden)

1. Voeg een field toe voor de timer:

    [Export] public float SpawnInterval { get; set; } = 5.0f;

    private Timer _spawnTimer;
}

1. Sla het script op

_Ready implementeren (CarSpawner)

Maak een timer die periodiek cars spawnt.

1. Voeg een lege _Ready() method toe:

    private Timer _spawnTimer;

    public override void _Ready()
    {
    }
}

1. Creëer een Timer instance:

    public override void _Ready()
    {
        _spawnTimer = new Timer();
    }

1. Configureer de timer:

    public override void _Ready()
    {
        _spawnTimer = new Timer();
        _spawnTimer.WaitTime = SpawnInterval;
    }

1. Connect de Timeout signal:

        _spawnTimer.WaitTime = SpawnInterval;
        _spawnTimer.Timeout += OnSpawnTimerTimeout;
    }

1. Voeg de timer toe als child (moet in scene tree zitten om te werken):

        _spawnTimer.Timeout += OnSpawnTimerTimeout;
        AddChild(_spawnTimer);
    }

1. Start de timer:

        AddChild(_spawnTimer);
        _spawnTimer.Start();
    }

Timer lifecycle:

1. new Timer() - creëer timer object

2. WaitTime - stel interval in

3. Timeout += callback - subscribe naar timeout event

4. AddChild() - voeg toe aan scene (MOET, anders werkt timer niet!)

5. Start() - begin countdown

6. Sla het script op

OnSpawnTimerTimeout implementeren

Maak een callback die fired elke keer dat de timer timeout.

Nieuwe C#-specifieke elementen:

• RandomNumberGenerator - Godot's random number generator

• RandfRange() - Random float tussen min en max

1. Voeg een lege OnSpawnTimerTimeout() method toe:

    }

    private void OnSpawnTimerTimeout()
    {
    }
}

1. Creëer een random generator:

    private void OnSpawnTimerTimeout()
    {
        var random = new RandomNumberGenerator();
    }

1. Randomize het volgende spawn interval. Dit voorkomt voorspelbare spawns:

    private void OnSpawnTimerTimeout()
    {
        var random = new RandomNumberGenerator();
        _spawnTimer.WaitTime = random.RandfRange(SpawnInterval - 2, SpawnInterval + 2);
    }

Randomization:

• Base interval = 5 seconden

• Range = 3-7 seconden (5 ± 2)

• Geeft natuurlijker spawn pattern

1. Probeer een car te spawnen:

        _spawnTimer.WaitTime = random.RandfRange(SpawnInterval - 2, SpawnInterval + 2);
        TrySpawnCar();
    }

1. Sla het script op

TrySpawnCar implementeren

Maak een method die een car spawnt tussen twee random buildings.

1. Voeg een lege TrySpawnCar() method toe:

    }

    private void TrySpawnCar()
    {
    }
}

1. Haal alle building positions op:

    private void TrySpawnCar()
    {
        var buildings = GetBuildingPositions();
    }

1. Check of er minstens 2 buildings zijn (anders geen route mogelijk):

    private void TrySpawnCar()
    {
        var buildings = GetBuildingPositions();
        if (buildings.Count < 2)
            return;
    }

1. Kies een random start building:

        if (buildings.Count < 2)
            return;

        int startIndex = GetRandomIndex(buildings.Count);
        var startCell = buildings[startIndex];
    }

1. Vind een road naast de start building:

        var startCell = buildings[startIndex];
        var spawnPosition = FindRoadNearBuilding(startCell);
    }

1. Kies een random target building (moet verschillend zijn van start):

        var spawnPosition = FindRoadNearBuilding(startCell);

        int targetIndex = GetRandomIndex(buildings.Count, startIndex);
        var targetCell = buildings[targetIndex];
    }

GetRandomIndex met exclude:

• Eerste parameter = aantal buildings

• Tweede parameter = index om te skippen (start building)

• Garandeert dat start ≠ target

1. Vind een road naast de target building:

        var targetCell = buildings[targetIndex];
        var targetPosition = FindRoadNearBuilding(targetCell);
    }

1. Spawn de car:

        var targetPosition = FindRoadNearBuilding(targetCell);

        SpawnCar(spawnPosition, targetPosition);
    }

1. Sla het script op

GetBuildingPositions implementeren

Maak een method die alle building cells vindt.

1. Voeg een lege GetBuildingPositions() method toe:

    }

    private List<Vector3I> GetBuildingPositions()
    {
    }
}

1. Maak een lege lijst:

    private List<Vector3I> GetBuildingPositions()
    {
        var buildings = new List<Vector3I>();
    }

1. Haal alle used cells op:

        var buildings = new List<Vector3I>();
        var usedCells = GridMap.GetUsedCells();
    }

1. Loop door alle cells en filter buildings:

        var usedCells = GridMap.GetUsedCells();

        foreach (Vector3I cell in usedCells)
        {
            int tileId = GridMap.GetCellItem(cell);
            if (IsBuildingTile(tileId))
            {
                buildings.Add(cell);
            }
        }
    }

1. Return de lijst:

            }
        }

        return buildings;
    }

1. Sla het script op

FindRoadNearBuilding implementeren

Maak een method die een adjacent road vindt naast een building.

1. Voeg een lege FindRoadNearBuilding() method toe:

    }

    private Vector3 FindRoadNearBuilding(Vector3I buildingCell)
    {
    }
}

1. Definieer de vier richtingen:

    private Vector3 FindRoadNearBuilding(Vector3I buildingCell)
    {
        Vector3I[] directions = { Vector3I.Forward, Vector3I.Right, Vector3I.Back, Vector3I.Left };
    }

1. Loop door alle richtingen:

        Vector3I[] directions = { Vector3I.Forward, Vector3I.Right, Vector3I.Back, Vector3I.Left };

        foreach (var direction in directions)
        {
        }
    }

1. Check de adjacent cell:

        foreach (var direction in directions)
        {
            Vector3I adjacentCell = buildingCell + direction;
            int tileId = GridMap.GetCellItem(adjacentCell);
        }

1. Return de positie als het een road is:

            int tileId = GridMap.GetCellItem(adjacentCell);

            if (IsRoadTile(tileId))
            {
                return GridMap.MapToLocal(adjacentCell);
            }
        }

MapToLocal:

• Converteer GridMap cell → wereld positie

• Car spawnt op deze positie

1. Return Vector3.Zero als geen road gevonden (fallback):

            }
        }
        return Vector3.Zero;
    }

1. Sla het script op

SpawnCar implementeren

Maak een method die de car instantiates en configureert.

1. Voeg een lege SpawnCar() method toe:

    }

    private void SpawnCar(Vector3 spawnPosition, Vector3 targetPosition)
    {
    }

    private List<Vector3I> GetBuildingPositions()

1. Instantiate de car scene:

    private void SpawnCar(Vector3 spawnPosition, Vector3 targetPosition)
    {
        var car = CarScene.Instantiate<Car>();
    }

Instantiate():

• Template syntax voor type-safe instantiation

• Return type = Car (niet gewoon Node)

• Toegang tot Car-specific methods (SetTargetPosition)

1. Voeg de car toe aan de scene tree:

        var car = CarScene.Instantiate<Car>();
        GetParent().AddChild(car);
    }

Waarom GetParent()?

• CarSpawner is child van Main

• We willen car als child van Main (niet van CarSpawner)

• GetParent() = Main node

1. Zet de spawn positie:

        GetParent().AddChild(car);
        car.GlobalPosition = spawnPosition;
    }

1. Zet de target:

        car.GlobalPosition = spawnPosition;

        car.SetTargetPosition(targetPosition);
    }

1. Sla het script op

Helper methods toevoegen

Voeg utility methods toe voor random selection en tile checking.

1. Voeg de GetRandomIndex() method toe. Deze heeft twee overloads - met en zonder exclude:

    }

    private static int GetRandomIndex(int count, int excludedIndex = -1)
    {
        if (excludedIndex == -1)
            return GD.RandRange(0, count - 1);

        int index = GD.RandRange(0, count - 2);
        return index >= excludedIndex ? index + 1 : index;
    }

    private void SpawnCar(Vector3 spawnPosition, Vector3 targetPosition)

Exclude logic:

• Als excludedIndex = -1 → gewoon random tussen 0 en count-1

• Anders: random tussen 0 en count-2, dan shift naar rechts als >= excluded

• Bijvoorbeeld: 5 buildings, exclude index 2 → kies uit [0,1,3,4]

1. Voeg de tile type checkers toe onderaan:

        return Vector3.Zero;
    }

    private bool IsBuildingTile(int tileId) => tileId >= 0 && tileId <= 4;
    private bool IsRoadTile(int tileId) => tileId >= 10 && tileId <= 14;
}

Tile ID ranges:

• 0-4 = buildings (5 types)

• 10-14 = roads (straight, corner, T, intersection, etc.)

• 7 = grass (niet checked hier)

1. Sla het script op

CarSpawner node toevoegen

Voeg de CarSpawner toe aan de Main scene.

1. Open scenes/Main.tscn (als deze nog niet open is)

2. Voeg een Node toe als child van Main

3. Hernoem naar CarSpawner

4. Selecteer CarSpawner

5. In de Inspector → Script: attach scripts/CarSpawner.cs

6. In de Inspector → CarSpawner script sectie:

   • Car Scene: klik het folder icoontje → selecteer scenes/Car.tscn

   • Grid Map: sleep GridMap node naar deze property

   • Spawn Interval: 5.0 (default is OK)

7. Sla de scene op (Ctrl+S)

Testen

Test het complete systeem.

1. Start het spel (F5)

2. Check of de MoneyDisplay "1000$" toont (starting money)

3. Plaats minstens 2 buildings

4. Plaats roads tussen de buildings (adjacent aan buildings)

5. Wacht 5-7 seconden (spawn interval):

   • Een car moet spawnen op een road naast een building

   • Car rijdt naar destination

   • Bij aankomst: money increase

   • Console: "Earned X. Total: Y" (X = path length × 10)

6. Observeer meerdere spawns:

   • Elke 3-7 seconden spawnt een nieuwe car

   • Interval is gerandomized

7. Test edge cases:

   • Plaats alleen 1 building → geen cars spawnen (need 2+ buildings)

   • Verwijder roads tussen buildings → cars kunnen niet spawnen (geen adjacent roads)

   • Bouw een complex wegnetwerk → cars nemen verschillende routes

8. Check money system:

   • Langere routes geven meer geld

   • Console prints path length bij elke spawn

Werkt alles? Sluit het spel (F8)

Veelgemaakte fouten

• Car beweegt niet: Controleer of NavigationAgent export is ingesteld. Check ook of er een geldig NavigationMesh is (hoofdstuk 10).

• Car rijdt niet over roads: NavigationMesh is leeg of niet gekoppeld. Controleer RoadNavigation setup in hoofdstuk 10.

• Car kantelt/valt om: Vergeet niet lookDirection.Y = 0 in te stellen. Rotatie mag alleen yaw hebben, geen pitch/roll.

• Cars spawnen niet: Check of CarScene export is ingesteld. Check console voor errors. Verify dat er 2+ buildings EN adjacent roads zijn.

• Cars spawnen in de lucht: FindRoadNearBuilding returnt Vector3.Zero (geen road gevonden). Plaats roads direct naast buildings.

• Timer werkt niet: AddChild(_spawnTimer) vergeten. Timers moeten in de scene tree zitten om te werken!

• GetRandomIndex crash: Buildings.Count < 2 check faalt. Verify de early return in TrySpawnCar.

• Path length is altijd 0: CalculatePathLength() wordt niet aangeroepen. Check of PathChanged signal correct is verbonden in _Ready().

• Slerp rotatie is te snel/langzaam: Pas RotationSpeed export aan (10.0 is standaard, hogere waarden = snellere draai).

Volledige scripts

Klik hier voor het volledige Car.cs script

using Godot;

public partial class Car : CharacterBody3D
{
    [Export] float Speed { get; set; } = 3.0f;
    [Export] float RotationSpeed { get; set; } = 10.0f;
    [Export] int MoneyPerUnit { get; set; } = 10;
    [Export] private NavigationAgent3D _navigationAgent;

    private int _pathLength = 0;

    public override void _Ready()
    {
        _navigationAgent.PathChanged += CalculatePathLength;
    }

    public void SetTargetPosition(Vector3 target)
    {
        _navigationAgent.TargetPosition = target;
    }

    private void CalculatePathLength()
    {
        var path = _navigationAgent.GetCurrentNavigationPath();
        if (path.Length < 2) return;

        _pathLength = path.Length - 1;
        GD.Print(_pathLength);

        _navigationAgent.PathChanged -= CalculatePathLength;
    }

    public override void _PhysicsProcess(double delta)
    {
        if (_navigationAgent.IsNavigationFinished())
        {
            int moneyEarned = _pathLength * MoneyPerUnit;
            GetNode<MoneyManager>("/root/MoneyManager").AddMoney(moneyEarned);

            QueueFree();
            return;
        }

        Vector3 nextPosition = _navigationAgent.GetNextPathPosition();
        Vector3 direction = (nextPosition - GlobalPosition).Normalized();

        Velocity = direction * Speed;

        Vector3 lookDirection = new Vector3(direction.X, 0, direction.Z);
        Basis targetBasis = Basis.LookingAt(lookDirection, Vector3.Up);
        Basis = Basis.Slerp(targetBasis, RotationSpeed * (float)delta);

        MoveAndSlide();
    }
}

Klik hier voor het volledige CarSpawner.cs script

using Godot;
using System;
using System.Collections.Generic;
using System.Linq;

public partial class CarSpawner : Node
{
    [Export] public PackedScene CarScene { get; set; }
    [Export] public GridMap GridMap { get; set; }
    [Export] public float SpawnInterval { get; set; } = 5.0f;

    private Timer _spawnTimer;

    public override void _Ready()
    {
        _spawnTimer = new Timer();
        _spawnTimer.WaitTime = SpawnInterval;
        _spawnTimer.Timeout += OnSpawnTimerTimeout;
        AddChild(_spawnTimer);
        _spawnTimer.Start();
    }

    private void OnSpawnTimerTimeout()
    {
        var random = new RandomNumberGenerator();
        _spawnTimer.WaitTime = random.RandfRange(SpawnInterval - 2, SpawnInterval + 2);
        TrySpawnCar();
    }

    private void TrySpawnCar()
    {
        var buildings = GetBuildingPositions();
        if (buildings.Count < 2)
            return;

        int startIndex = GetRandomIndex(buildings.Count);
        var startCell = buildings[startIndex];
        var spawnPosition = FindRoadNearBuilding(startCell);

        int targetIndex = GetRandomIndex(buildings.Count, startIndex);
        var targetCell = buildings[targetIndex];
        var targetPosition = FindRoadNearBuilding(targetCell);

        SpawnCar(spawnPosition, targetPosition);
    }

    private static int GetRandomIndex(int count, int excludedIndex = -1)
    {
        if (excludedIndex == -1)
            return GD.RandRange(0, count - 1);

        int index = GD.RandRange(0, count - 2);
        return index >= excludedIndex ? index + 1 : index;
    }

    private void SpawnCar(Vector3 spawnPosition, Vector3 targetPosition)
    {
        var car = CarScene.Instantiate<Car>();
        GetParent().AddChild(car);
        car.GlobalPosition = spawnPosition;

        car.SetTargetPosition(targetPosition);
    }

    private List<Vector3I> GetBuildingPositions()
    {
        var buildings = new List<Vector3I>();
        var usedCells = GridMap.GetUsedCells();

        foreach (Vector3I cell in usedCells)
        {
            int tileId = GridMap.GetCellItem(cell);
            if (IsBuildingTile(tileId))
            {
                buildings.Add(cell);
            }
        }

        return buildings;
    }

    private Vector3 FindRoadNearBuilding(Vector3I buildingCell)
    {
        Vector3I[] directions = { Vector3I.Forward, Vector3I.Right, Vector3I.Back, Vector3I.Left };

        foreach (var direction in directions)
        {
            Vector3I adjacentCell = buildingCell + direction;
            int tileId = GridMap.GetCellItem(adjacentCell);

            if (IsRoadTile(tileId))
            {
                return GridMap.MapToLocal(adjacentCell);
            }
        }
        return Vector3.Zero;
    }

    private bool IsBuildingTile(int tileId) => tileId >= 0 && tileId <= 4;
    private bool IsRoadTile(int tileId) => tileId >= 10 && tileId <= 14;
}