5. Building Placement

Implementeer een building placement systeem met validatie en auto-rotation

Overzicht

In dit hoofdstuk leer je:

• BuildingPlacer script maken

• Click-to-place buildings implementeren

• Placement validatie (alleen op grass)

• Buildings auto-roteren naar aangrenzende wegen

• GridMap orientation system gebruiken

Placement Rules

Een building kan alleen geplaatst worden als:

1. De cell bevat grass (tile ID 7)

2. Er is minimaal één aangrenzende weg (tile ID 14)

Als beide voorwaarden kloppen, roteert het building automatisch om naar de weg te wijzen!

Dit creëert een natuurlijke stad layout waar buildings altijd toegankelijk zijn via wegen.

BuildingPlacer Setup

Maak de basis node en het script voor het plaatsen van gebouwen.

1. Node aanmaken:

   • Open scenes/main.tscn

   • Voeg een Node3D child toe aan Main en noem deze BuildingPlacer

2. Voeg een script toe aan de nieuwe BuildingPlacer Node

Nieuwe Godot-specifieke elementen:

• GridMap.SetCellItem() - Plaatst een tile op een specifieke cell met rotatie

• GridMap.GetCellItem() - Leest welke tile er op een cell staat

• GridMap.GetOrthogonalIndexFromBasis() - Converteert een 3D rotatie naar een GridMap orientation index (0-23)

1. Open scripts/BuildingPlacer.cs

2. Voeg de using directive en class declaratie toe:

using Godot;

public partial class BuildingPlacer : Node3D
{
}

1. Voeg exports toe voor referenties naar de Raycaster en GridMap. Deze heb je nodig om te detecteren waar de muis is en om tiles te plaatsen.

public partial class BuildingPlacer : Node3D
{
    [Export] public GridMapRaycaster Raycaster { get; set; }
    [Export] public GridMap GridMap { get; set; }
}

1. Voeg exports toe voor de tile IDs die je wilt herkennen. Deze IDs verwijzen naar de grass en road tiles in je MeshLibrary.

public partial class BuildingPlacer : Node3D
{
    [Export] public GridMapRaycaster Raycaster { get; set; }
    [Export] public GridMap GridMap { get; set; }

    [Export] public int GrassTileId { get; set; } = 7;
    [Export] public int RoadTileId { get; set; } = 14;
}

1. Voeg een property toe voor het geselecteerde building ID. Later kun je dit gebruiken voor een building selector UI.

public partial class BuildingPlacer : Node3D
{
    [Export] public GridMapRaycaster Raycaster { get; set; }
    [Export] public GridMap GridMap { get; set; }

    [Export] public int GrassTileId { get; set; } = 7;
    [Export] public int RoadTileId { get; set; } = 14;

    public int SelectedBuildingId { get; set; } = 0;
}

Validatie Logica Implementeren

Implementeer de logica om te bepalen of een building geplaatst kan worden en in welke richting deze moet staan.

1. Voeg een lege private method toe FindAdjacentRoad. Deze method checkt de 4 buren (Noord, Oost, Zuid, West) en geeft de juiste rotatie terug als er een weg is. Het return type int? betekent dat de method null kan teruggeven als er geen weg is.

    public int SelectedBuildingId { get; set; } = 0;

    private int? FindAdjacentRoad(Vector3I cell)
    {
    }
}

1. Definieer een array met de 4 aangrenzende cells. Vector3I.Back is zuid, Vector3I.Right is oost, etc. Dit zijn de 4 buren in GridMap coordinaten.

    private int? FindAdjacentRoad(Vector3I cell)
    {
        Vector3I[] neighbors =
        {
            cell + Vector3I.Back,    // South
            cell + Vector3I.Right,   // East
            cell + Vector3I.Forward, // North
            cell + Vector3I.Left     // West
        };
    }

1. Definieer de bijbehorende rotaties in graden. Als er een weg aan de zuidkant is (index 0), moet het building 0° roteren (naar het zuiden wijzen). Bij oost 90°, noord 180°, west 270°.

    private int? FindAdjacentRoad(Vector3I cell)
    {
        Vector3I[] neighbors =
        {
            cell + Vector3I.Back,    // South
            cell + Vector3I.Right,   // East
            cell + Vector3I.Forward, // North
            cell + Vector3I.Left     // West
        };

        float[] rotations = { 0, 90, 180, 270 };
    }

1. Voeg een lege for-loop toe om door alle buren te itereren:

    private int? FindAdjacentRoad(Vector3I cell)
    {
        Vector3I[] neighbors =
        {
            cell + Vector3I.Back,    // South
            cell + Vector3I.Right,   // East
            cell + Vector3I.Forward, // North
            cell + Vector3I.Left     // West
        };

        float[] rotations = { 0, 90, 180, 270 };

        for (int i = 0; i < neighbors.Length; i++)
        {
        }
    }

1. Check voor elke buur of het een weg is. GetCellItem() geeft het tile ID terug, of -1 als de cell leeg is.

        for (int i = 0; i < neighbors.Length; i++)
        {
            int neighborTile = GridMap.GetCellItem(neighbors[i]);
            if (neighborTile == RoadTileId)
            {
            }
        }
    }

1. Bereken de GridMap orientation index als er een weg gevonden is. Maak eerst een rotatie Basis, converteer deze dan naar een GridMap index (0-23) met GetOrthogonalIndexFromBasis(). GridMap gebruikt indices 0-23 voor rotaties. GetOrthogonalIndexFromBasis converteert een normale 3D rotatie naar de juiste index voor de GridMap.

        for (int i = 0; i < neighbors.Length; i++)
        {
            int neighborTile = GridMap.GetCellItem(neighbors[i]);
            if (neighborTile == RoadTileId)
            {
                Basis basis = Basis.Identity.Rotated(Vector3.Up, Mathf.DegToRad(rotations[i]));
                return GridMap.GetOrthogonalIndexFromBasis(basis);
            }
        }
    }

1. Return null als er geen weg gevonden is na de loop:

        for (int i = 0; i < neighbors.Length; i++)
        {
            int neighborTile = GridMap.GetCellItem(neighbors[i]);
            if (neighborTile == RoadTileId)
            {
                Basis basis = Basis.Identity.Rotated(Vector3.Up, Mathf.DegToRad(rotations[i]));
                return GridMap.GetOrthogonalIndexFromBasis(basis);
            }
        }

        return null;
    }

1. Voeg een lege public method CanBuild toe. Deze method checkt of er gebouwd mag worden op de huidige muispositie.

    public bool CanBuild()
    {
    }

1. Haal de cell onder de muis op. Return false als er geen cell is (muis buiten de GridMap).

    public bool CanBuild()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return false;
    }

1. Check of de cell gras is. Return false als het geen gras is (bijvoorbeeld een weg of ander building).

    public bool CanBuild()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return false;

        int currentTileId = GridMap.GetCellItem(cell.Value);
        if (currentTileId != GrassTileId)
            return false;
    }

1. Check of er een aangrenzende weg is. Return het resultaat van FindAdjacentRoad() - true als er een weg is, false als er geen weg is.

    public bool CanBuild()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return false;

        int currentTileId = GridMap.GetCellItem(cell.Value);
        if (currentTileId != GrassTileId)
            return false;

        return FindAdjacentRoad(cell.Value) != null;
    }

Building Placement Implementeren

Implementeer de daadwerkelijke plaatsing en input handling.

Nieuwe Godot-specifieke elementen:

• _Input() - Ontvangt alle input events (toetsenbord, muis, etc.)

• IsActionPressed() - Checkt of een input action net is ingedrukt (één keer per klik)

1. Voeg een lege public method Build toe. Deze method plaatst het building op de huidige muispositie.

    public bool CanBuild()
    {
        // ...
    }

    public void Build()
    {
    }

    private int? FindAdjacentRoad(Vector3I cell)

1. Haal de cell onder de muis op. Return als er geen cell is.

    public void Build()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return;
    }

1. Bereken de rotatie op basis van de aangrenzende weg. Return als er geen weg is (dit zou niet moeten gebeuren als CanBuild() eerst aangeroepen is).

    public void Build()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return;

        int? orientation = FindAdjacentRoad(cell.Value);
        if (orientation == null)
            return;
    }

1. Plaats het gebouw met SetCellItem(). Deze method accepteert de cell positie, het tile ID, en de orientation index.

    public void Build()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return;

        int? orientation = FindAdjacentRoad(cell.Value);
        if (orientation == null)
            return;

        GridMap.SetCellItem(cell.Value, SelectedBuildingId, orientation.Value);
    }

1. Voeg een lege _Input() method toe. Deze ontvangt alle input events van Godot.

    public void Build()
    {
        // ...
    }

    public override void _Input(InputEvent @event)
    {
    }

    private int? FindAdjacentRoad(Vector3I cell)

1. Check of de "build" action is ingedrukt (linkermuisknop):

    public override void _Input(InputEvent @event)
    {
        if (@event.IsActionPressed("build"))
        {
        }
    }

1. Valideer met CanBuild() en roep Build() aan als het mag:

    public override void _Input(InputEvent @event)
    {
        if (@event.IsActionPressed("build"))
        {
            if (CanBuild())
            {
                Build();
            }
        }
    }

Configuratie en Testen

1. Koppelen in Editor:

   • Selecteer de BuildingPlacer node

   • Sleep het script naar het Script slot

   • Belangrijk: Sleep de GridMapRaycaster en GridMap nodes naar de export velden!

2. Testen:

   • Run de game (F5)

   • Probeer een gebouw te plaatsen naast een weg (op gras) -> Succes!

   • Probeer te plaatsen zonder weg -> Geen actie

   • Probeer te plaatsen op de weg -> Geen actie

   • Merk op dat het gebouw automatisch naar de weg draait.

Samenvatting

Je hebt nu een slim placement systeem!

Kernpunten:

• Validatie zorgt dat gebouwen logisch geplaatst worden.

• FindAdjacentRoad bepaalt dynamisch de rotatie.

• De GridMap API (SetCellItem, GetCellItem) beheert de grid state.

• Buildings roteren automatisch naar aangrenzende wegen.

• Input handling met _Input() voor click-to-place interactie.

Volledig script

Klik hier voor het volledige BuildingPlacer.cs script

using Godot;

public partial class BuildingPlacer : Node3D
{
    [Export] public GridMapRaycaster Raycaster { get; set; }
    [Export] public GridMap GridMap { get; set; }

    [Export] public int GrassTileId { get; set; } = 7;
    [Export] public int RoadTileId { get; set; } = 14;

    public int SelectedBuildingId { get; set; } = 0;

    public override void _Input(InputEvent @event)
    {
        if (@event.IsActionPressed("build"))
        {
            if (CanBuild())
            {
                Build();
            }
        }
    }

    public void Build()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return;

        int? orientation = FindAdjacentRoad(cell.Value);
        if (orientation == null)
            return;

        GridMap.SetCellItem(cell.Value, SelectedBuildingId, orientation.Value);
    }

    public bool CanBuild()
    {
        Vector3I? cell = Raycaster.GetCellUnderMouse();
        if (cell == null)
            return false;

        int currentTileId = GridMap.GetCellItem(cell.Value);
        if (currentTileId != GrassTileId)
            return false;

        return FindAdjacentRoad(cell.Value) != null;
    }

    private int? FindAdjacentRoad(Vector3I cell)
    {
        Vector3I[] neighbors =
        {
            cell + Vector3I.Back,    // South
            cell + Vector3I.Right,   // East
            cell + Vector3I.Forward, // North
            cell + Vector3I.Left     // West
        };

        float[] rotations = { 0, 90, 180, 270 };

        for (int i = 0; i < neighbors.Length; i++)
        {
            int neighborTile = GridMap.GetCellItem(neighbors[i]);
            if (neighborTile == RoadTileId)
            {
                Basis basis = Basis.Identity.Rotated(Vector3.Up, Mathf.DegToRad(rotations[i]));
                return GridMap.GetOrthogonalIndexFromBasis(basis);
            }
        }

        return null;
    }
}