5. Enemies

Creëer enemies die naar de speler kijken en schieten met herbruikbare components

Overzicht

In dit hoofdstuk maak je een enemy die automatisch naar de speler kijkt en schiet. Je leert hoe je code hergebruikt door bestaande scripts (Target.cs en Railgun.cs) toe te passen op een nieuwe context. De enemy gebruikt compositie - je bouwt complex gedrag door simpele, herbruikbare componenten te combineren.

Enemy model collider

Maak een enemy om op te schieten. Gebruik het enemy-flying.glb model uit de assets, precies zoals je eerder de Target hebt gemaakt in Chapter 4. Voor je daarmee van start gaat, moet je er eerst voor zorgen dat je de enemy kunt raken. Gebruik een RigidBody3D zodat de enemy realistisch reageert op projectiles - het kan kantelen, vallen of omvallen wanneer het geraakt wordt.

1. Dubbelklik op models/enemy-flying.glb in het FileSystem venster om de import settings te openen

2. In het Import venster in het Scene Hierarchy venster, selecteer de torso node

3. Aan de rechterkant vind je de import-opties

4. Vink Physics aan in het generate gedeelte

5. In de Physics sectie daaronder, zet Body Type op Dynamic

6. Klik onderaan op Reimport

Enemy scene setup

Nu ons enemy model een collider heeft, kun je een eigen Enemy scene maken. Het enemy-flying model heeft een geneste structuur met een RigidBody3D genaamd "torso" die we gaan gebruiken voor destruction.

1. Ga in de menu naar Scene > Open Scene...

2. Navigeer naar models/enemy-flying.glb

3. Klik op Open

4. Godot toont een waarschuwing dat je enemy-flying niet rechtstreeks kunt aanpassen, maar je kan wel een nieuwe scene maken gebaseerd op dit Asset. Klik daarom op New Inherited

5. Selecteer de enemy-flying root node in de hierarchy en hernoem deze naar Enemy

6. Sla de scene op als res://objects/Enemy.tscn

Je scene hierarchy zou er nu zo uit moeten zien:

Enemy (Node3D)
└── root (Node3D)
    ├── torso (RigidBody3D)
    │   ├── antenna (MeshInstance3D)
    │   ├── torso (MeshInstance3D)
    │   └── CollisionShape3D
    ├── blaster-left (MeshInstance3D)
    └── blaster-right (MeshInstance3D)

Target script herbruiken

De enemy moet vernietigd kunnen worden wanneer hij geraakt wordt door een projectile. Dit heb je al geïmplementeerd in Chapter 4! Het Target.cs script werkt perfect voor de enemy - het detecteert hits en vernietigt de parent node.

Het character-enemy model heeft een torso RigidBody3D - dit is de physics body die door projectiles geraakt kan worden. Voeg Target.cs toe aan deze torso-node.

1. Open objects/Enemy.tscn (als het nog niet open staat)

2. Selecteer de torso child node (dit is de RigidBody3D onder root)

3. Klik Attach Script (het 📜 icoontje met een +, bovenaan het Scene Hierarchy venster)

4. In het "Attach Node Script" venster, klik op het folder icoon naast Path

5. Navigeer naar scripts/Target.cs

6. Selecteer Target.cs en klik Open

7. Klik Load

8. Sleep de Enemy node naar de Root property in de inspector

9. Sla de Enemy scene op

Railgun script herbruiken

Hergebruik nu het weapon-systeem! In plaats van nieuwe shooting code te schrijven, gebruik je gewoon de bestaande blaster nodes in het model. Het enemy-flying model heeft al twee blaster visual nodes (blaster-left en blaster-right). Voeg het Railgun.cs-script toe aan deze nodes - zo krijgt de enemy exact dezelfde shooting mechanics als de speler!

1. Selecteer de blaster-left node (dit is een MeshInstance3D onder root)

2. Klik Attach Script (het icoontje met een +)

3. In het "Attach Node Script" venster, klik op het folder icoon naast Path

4. Navigeer naar scripts/Railgun.cs

5. Selecteer Railgun.cs en klik Open

6. Klik Load

7. Doe nu hetzelfde voor de blaster-right

8. Sla de Enemy scene op

Weapon components toevoegen

Elk weapon heeft dezelfde components nodig als de player's railgun: een Timer, een Muzzle marker, en een weapon mount point.

1. Selecteer de blaster-left node

2. Rechts-klik > Add Child Node > Timer

3. Hernoem naar FireRateTimer

4. Configureer in de Inspector:

   • Wait Time: 0.5

   • One Shot: Aan

   • Autostart: Uit

5. Selecteer de blaster-left node opnieuw

6. Rechts-klik > Add Child Node > Marker3D

7. Hernoem naar Muzzle

8. Positioneer de Muzzle aan het uiteinde van de blaster (gebruik Move tool)

9. Herhaal stappen 1-8 voor blaster-right

10. Sla de scene op

Je scene hierarchy is nu:

Enemy (Node3D)
├── root (Node3D)
│   └── torso (RigidBody3D) - Target.cs
│       ├── antenna (MeshInstance3D)
│       ├── torso (MeshInstance3D)
│       └── CollisionShape3D
├── blaster-left (MeshInstance3D) - Railgun.cs
│   ├── FireRateTimer (Timer)
│   └── Muzzle (Marker3D)
└── blaster-right (MeshInstance3D) - Railgun.cs
    ├── FireRateTimer (Timer)
    └── Muzzle (Marker3D)

Enemy aimraycast toevoegen

Net zoals de speler, heeft de enemy een RayCast3D nodig om te bepalen waar zijn weapons naar moeten schieten. Deze raycast wijst altijd in de richting waarin de enemy kijkt.

1. In objects/Enemy.tscn, selecteer de Enemy root node

2. Rechts-klik > Add Child Node > RayCast3D

3. Hernoem naar AimRaycast

4. In de Inspector:

   • Target Position: x: 0, y: 0, z: -100 - 100 meter vooruit

   • Enabled: AAN (altijd actief)

   • Collide With Areas: UIT (alleen solid bodies)

5. Sla de scene op

Je scene hierarchy is nu:

Enemy (Node3D)
├── AimRaycast (RayCast3D)
├── root (Node3D)
│   └── torso (RigidBody3D) - Target.cs
│       ├── antenna (MeshInstance3D)
│       ├── torso (MeshInstance3D)
│       └── CollisionShape3D
├── blaster-left (MeshInstance3D) - Railgun.cs
│   ├── FireRateTimer (Timer)
│   └── Muzzle (Marker3D)
└── blaster-right (MeshInstance3D) - Railgun.cs
    ├── FireRateTimer (Timer)
    └── Muzzle (Marker3D)

Configure enemy railguns

De Enemy's Railguns hebben dezelfde configuration nodig als de Player's Railgun: een weapon mount point, muzzle marker, en fire rate timer.

Voor de weapon mount, gebruiken we gewoon de blaster nodes zelf.

1. In objects/Enemy.tscn, selecteer de blaster-left node

2. In de Inspector, zie je de exported properties:

   • Fire Rate Timer: Sleep de FireRateTimer (child van blaster-left) hiernaartoe

   • Weapon Mount: Klik Assign > selecteer blaster-left (zichzelf)

   • Muzzle: Sleep de Muzzle (child van blaster-left) hiernaartoe

3. Doe nu hetzelfde voor blaster-right

4. Sla de scene op

Enemy ai script

Nu maken we het Enemy script dat de AI afhandelt. De enemy moet:

1. Naar de speler kijken (LookAt)

2. Het Shoot signal uitzenden met de raycast (net zoals Player)

1. Selecteer de Enemy root node

2. Klik Attach Script

   • Language: C#

   • Class Name: Enemy

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

3. Klik Create

4. Voeg een Shoot Signal toe aan het Enemy script dat de raycast parameter accepteert:

using Godot;

public partial class Enemy : Node3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);
}

1. Voeg referenties toe voor de speler en de aim raycast:

using Godot;

public partial class Enemy : Node3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);

    [Export] private RayCast3D _aimRaycast;
    private Node3D _player;
}

1. Wanneer de enemy spawnt, zoek je naar een speler in de scene:

using Godot;

public partial class Enemy : Node3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);

    [Export] private RayCast3D _aimRaycast;
    private Node3D _player;

    public override void _Ready()
    {
        _player = GetTree().Root.FindChild("Player", recursive: true) as Node3D;
    }
}

1. Laat de Enemy nu elke frame (dus in _Process(delta)) draaien in de richting van de speler:

using Godot;

public partial class Enemy : Node3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);

    [Export] private RayCast3D _aimRaycast;
    private Node3D _player;

    public override void _Ready()
    {
        _player = GetTree().Root.FindChild("Player", recursive: true) as Node3D;
    }

    public override void _Process(double delta)
    {
        if (_player != null)
        {
            LookAt(_player.GlobalPosition);
        }
    }
}

1. Wanneer de enemy kijkt naar de speler, stuurt het het Shoot-signaal uit met de raycast:

using Godot;

public partial class Enemy : Node3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);

    [Export] private RayCast3D _aimRaycast;
    private Node3D _player;

    public override void _Ready()
    {
        _player = GetTree().Root.FindChild("Player", recursive: true) as Node3D;
    }

    public override void _Process(double delta)
    {
        if (_player != null)
        {
            LookAt(_player.GlobalPosition);
            EmitSignal(SignalName.Shoot, _aimRaycast);
        }
    }
}

1. Selecteer de Enemy root node in de Editor

2. In de Inspector, sleep de AimRaycast node naar de Aim Raycast property

3. Sla de scene op

Connect enemy shoot signal

Net zoals je in Chapter 3 de Player's Shoot signal hebt verbonden met de Railgun, moet je nu het Shoot-signaal van de Enemy verbinden met beide railgun weapons.

1. Selecteer de Enemy root node in de hierarchy

2. Aan de rechterkant van de Editor, naast de Inspector tab, vind je het Node venster (klik erop als het niet zichtbaar is)

3. Met de Enemy geselecteerd, zie je in het Node venster alle signals die de Enemy kan uitzenden

4. Dubbelklik op het Shoot signal

5. In het venster "Connect a Signal to a Method" selecteer je de blaster-left child node (dit is de ontvanger)

6. Bij Receiver Method klik op Pick

7. Selecteer de OnShoot method uit de lijst

8. Klik op Connect

9. Herhaal deze stappen voor de blaster-right

10. In de Scene Hierarchy zie je nu een signaal-icoontje naast de Enemy node

11. Sla de scene op

Add enemy to main scene

Voeg nu de Enemy toe aan het level en test!

1. Open scenes/main.tscn

2. Sleep de Enemy.tscn scene naar de hierarchy of viewport

3. Positioneer de enemy zodat je hem kan zien vanaf de spawn positie van de speler

   • Bijvoorbeeld: Position (-5, 1, -10)

4. Run de scene met F6

5. De enemy zou automatisch naar je moeten kijken

6. De enemy zou automatisch moeten schieten

7. Schiet terug met linker muisknop

8. Wanneer je de enemy raakt, zou hij moeten verdwijnen!

9. Sla main.tscn op

Complete scripts

Het volledige Enemy script

Enemy.cs

using Godot;

public partial class Enemy : Node3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);

    [Export] private RayCast3D _aimRaycast;
    private Node3D _player;

    public override void _Ready()
    {
        _player = GetTree().Root.FindChild("Player", recursive: true) as Node3D;
    }

    public override void _Process(double delta)
    {
        if (_player != null)
        {
            LookAt(_player.GlobalPosition);
            EmitSignal(SignalName.Shoot, _aimRaycast);
        }
    }
}