4. Raycast Hit Detection

Implementeer instant-hit raycast shooting met accurate central aiming

Overzicht

In dit hoofdstuk implementeer je een shooting systeem met instant hit detection. Je maakt een target om op te schieten en gebruikt een central raycast voor accurate aiming - precies waar je crosshair naar kijkt.

Target scene maken

1. Maak een nieuwe scene aan

2. Voeg een RigidBody3D node toe

3. Sleep models/target-detail.glb in de scene, als child van de RidigBody

4. Voeg aan de RigidBody ook een CollisionShape3D toe

5. Selecteer de CollisionShape3D, en pas de Shape property aan naar CylinderShape3D in de inspector

6. Draai de CollisionShape3D 90° rond de Z-as

7. Gebruik de rode handles om de Collisionshape ongeveer dezelfde grootte te geven als het target

8. Sla de scene op als objects/target.tscn

1. Open scenes/main.tscn

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

3. Positioneer het target zodat je het kan zien vanaf de spawn positie van de speler

4. Test met F6 - je zou het target moeten kunnen zien

AimRaycast Toevoegen

In FPS games is het belangrijk dat je schiet waarop je mikt. De meeste games gebruiken een raycast systeem waar de crosshair in het midden van het scherm exact overeenkomt met wat je raakt.

Voeg een RayCast3D toe aan de camera die altijd recht vooruit kijkt - dit is wat de crosshair vertegenwoordigt.

1. Open objects/Player.tscn

2. Selecteer de Camera3D node

3. Rechts-klik > Add Child Node > RayCast3D

4. Hernoem naar AimRaycast

5. 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)

6. Zet de raycast een beetje voor de speler, zodat je jezelf niet raakt

7. Sla de scene op

Scene hierarchy:

Player (CharacterBody3D)
├── Camera3D
│   ├── AimRaycast (RayCast3D)
│   └── WeaponMount (Node3D)
└── CollisionShape3D

Railgun fire method

Wanneer de speler schiet, geeft de Player de volledige raycast door aan het wapen. Het wapen kan dan zelf bepalen wat er geraakt is en waar precies de hit was. Dit geeft ons alle informatie die we nodig hebben: het geraakt object én het exacte collision point.

Pas daarom het Shoot-signaal aan van de Player, zodat het de raycast meegeeft als parameter. Daarna passen we het Railgun script aan om te checken of de raycast een Target raakt en deze te vernietigen.

1. Open scripts/player.cs

2. Voeg een raycast parameter toe aan de ShootEventHandler:

public partial class Player : CharacterBody3D
{
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);
    // ... rest van de code
}

1. Voeg een [Export] variabele toe om de AimRaycast te kunnen gebruiken.

public partial class Player : CharacterBody3D
{
	  [Export] private RayCast3D _aimRaycast;
    [Signal]
    public delegate void ShootEventHandler(RayCast3D raycast);
    // ... rest van de code
}

1. Wanneer je het Shoot signaal uitstuurt, geef je de hele raycast mee:

public override void _Process(double delta)
{
    if (Input.IsActionJustPressed("shoot"))
    {
        // Stuur de raycast naar het wapen
        EmitSignal(SignalName.Shoot, _aimRaycast);
        GD.Print($"Hit: {_aimRaycast.GetCollisionPoint()}");
    }
}

1. Open scripts/railgun.cs

2. Pas de OnShoot() method aan om de raycast te ontvangen:

public void OnShoot(RayCast3D raycast)
{
    // Check of we nog in cooldown zitten
    if (!_fireRateTimer.IsStopped())
        return;

    // Start de cooldown timer
    _fireRateTimer.Start();

    // Toon een beam vanaf de muzzle 100 units vooruit
    Vector3 beamEnd = _muzzle.GlobalPosition - _muzzle.GlobalBasis.Z * 100;
    ShowBeam(_muzzle.GlobalPosition, beamEnd);

    GD.Print("Railgun fired!");
}

Uitleg:

• RayCast3D raycast: De volledige raycast van de Player

• raycast.GetCollider(): Haal het geraakt object op

• is Target targetHit: Pattern matching - check type en cast in één keer

• targetHit.OnHit(): Roep de OnHit method aan op het Target object

• Nu gebruiken we ook raycast.GetCollisionPoint() om de beam te updaten naar het exacte hit point

Beam naar hit point

Nu we de raycast hebben, kunnen we de beam visualisatie updaten zodat deze naar het exacte collision point wijst in plaats van alleen vooruit.

1. Open scripts/Railgun.cs

2. Update de OnShoot() method om de beam naar het raycast hit point te richten:

public void OnShoot(RayCast3D raycast)
{
    // Check of we nog in cooldown zitten
    if (!_fireRateTimer.IsStopped())
        return;

    // Start de cooldown timer
    _fireRateTimer.Start();
    
    // Bepaal het eindpunt van de beam
    Vector3 beamEnd = raycast.IsColliding()
        ? raycast.GetCollisionPoint()
        : _muzzle.GlobalPosition - raycast.GlobalBasis.Z * 100;

    // Teken de beam naar het hit point
    ShowBeam(_muzzle.GlobalPosition, beamEnd);

    GD.Print("Railgun fired!");
}

1. Test met F6 - de beam wijst nu naar het exacte punt waar de raycast raakt!

AimRaycast Toewijzen

1. Open objects/Player.tscn

2. Selecteer de Player node

3. In de Inspector zie je nu de Aim Raycast property

4. Sleep de AimRaycast node naar deze property

5. Sla de scene op

6. Test met F5 - klik met de muis en kijk naar de Output tab

Target script

Nu maken we het zo dat targets vernietigd worden wanneer ze geraakt worden door de raycast.

1. Open objects/Target.tscn

2. Selecteer de RigidBody3D child node

3. Attach een nieuw script:

   • Class Name: Target

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

4. Voeg een _root field en OnHit() method toe:

using Godot;

public partial class Target : RigidBody3D
{
    [Export] private Node3D _root;

    public void OnHit()
    {
        GD.Print("Target destroyed!");

        // Verwijder de hele Target scene
        _root.QueueFree();
    }
}

1. Ga terug naar de Godot Editor

2. Selecteer de RigidBody3D node (waar het script op zit)

3. In de Inspector zie je nu de Root property

4. Sleep de Target root node (de parent Node3D) naar deze property

5. Sla de scene op

Waarom een _root field? Door de root node expliciet toe te wijzen, kan het script werken met verschillende scene structuren. Later kunnen we dit script hergebruiken voor enemies die misschien een andere node hierarchy hebben.

Target destruction

Nu hoef je alleen nog de OnHit()-methode op het Target object aan te roepen wanneer het Railgun een Target raakt.

1. Check of de raycast een Target raakt:

   • raycast.GetCollider(): Haal het geraakt object op uit de raycast

   • is Target targetHit: Pattern matching - check type en cast in één keer

   • targetHit.OnHit(): Roep de OnHit method aan om het target te vernietigen

public void OnShoot(RayCast3D raycast)
{
    // Check of we nog in cooldown zitten
    if (!_fireRateTimer.IsStopped())
        return;
        
    // Start de cooldown timer
    _fireRateTimer.Start();
    
    // Bepaal het eindpunt van de beam
    Vector3 beamEnd = raycast.IsColliding()
        ? raycast.GetCollisionPoint()
        : _muzzle.GlobalPosition - raycast.GlobalBasis.Z * 100;
    
    // Teken de beam naar het hit point
    ShowBeam(_muzzle.GlobalPosition, beamEnd);
    
    if (raycast.GetCollider() is Target targetHit)
        targetHit.OnHit();
        
    GD.Print("Railgun fired!");
}

Test het shooting system

1. Run de scene met F6

2. Beweeg met WASD en kijk rond met de muis

3. Klik met de linker muisknop om te schieten

4. Mik op het target - het zou instant moeten verdwijnen wanneer het midden van het scherm erop staat!

5. Kijk naar de Output tab om de hit detection berichten te zien

Troubleshooting:

• Raycast raakt niets? Check of AimRaycast Enabled is en Target Position correct is (-100 in Z)

• Targets verdwijnen niet? Check of je de AimRaycast hebt toegewezen in de Player Inspector

• "Hit: ..." verschijnt niet? Check of het Shoot signaal correct is verbonden met het Railgun

Complete scripts

De volledige Target, Player en Railgun scripts:

Target.cs

using Godot;

public partial class Target : RigidBody3D
{
    [Export] private Node3D _root;

    public void OnHit()
    {
        GD.Print("Target destroyed!");

        // Verwijder de hele Target scene
        _root.QueueFree();
    }
}

Player.cs (_Process method)

[Export] private RayCast3D _aimRaycast;
[Signal]
public delegate void ShootEventHandler(RayCast3D raycast);

public override void _Process(double delta)
{
    if (Input.IsActionJustPressed("shoot"))
    {
        // Stuur de raycast naar het wapen
        EmitSignal(SignalName.Shoot, _aimRaycast);
        GD.Print($"Hit: {_aimRaycast.GetCollisionPoint()}");
    }
}

Railgun.cs (Updated)

using Godot;

public partial class Railgun : Node3D
{
    [Export] private Timer _fireRateTimer;
    [Export] private Node3D _weaponMount;
    [Export] private Marker3D _muzzle;

    public override void _Process(double delta)
    {
        // Volg de weapon mount position
        GlobalPosition = _weaponMount.GlobalPosition;
        GlobalRotation = _weaponMount.GlobalRotation;
    }

    public void OnShoot(RayCast3D raycast)
    {
        // Check of we nog in cooldown zitten
        if (!_fireRateTimer.IsStopped())
            return;

        // Start de cooldown timer
        _fireRateTimer.Start();

        // Bepaal het eindpunt van de beam
        Vector3 beamEnd = raycast.IsColliding()
            ? raycast.GetCollisionPoint()
            : _muzzle.GlobalPosition - raycast.GlobalBasis.Z * 100;

        // Teken de beam naar het hit point
        ShowBeam(_muzzle.GlobalPosition, beamEnd);

        // Check target hit
        if (raycast.GetCollider() is Target targetHit)
            targetHit.OnHit();

        GD.Print("Railgun fired!");
    }

    private void ShowBeam(Vector3 start, Vector3 end)
    {
        // Maak een cilinder mesh voor de beam
        var beamMesh = new CylinderMesh();
        beamMesh.TopRadius = 0.02f;
        beamMesh.BottomRadius = 0.02f;
        beamMesh.Height = 1.0f;

        var material = new StandardMaterial3D();
        material.ShadingMode = BaseMaterial3D.ShadingModeEnum.Unshaded;
        material.AlbedoColor = Colors.Cyan;
        material.NoDepthTest = true;  // Teken altijd op de voorgrond

        var beamInstance = new MeshInstance3D
        {
            Mesh = beamMesh,
            MaterialOverride = material,
            CastShadow = GeometryInstance3D.ShadowCastingSetting.Off
        };

        GetTree().Root.AddChild(beamInstance);

        // Positioneer en roteer de beam
        Vector3 direction = end - start;
        float distance = direction.Length();

        beamInstance.GlobalPosition = start + direction / 2;
        beamInstance.LookAt(end, Vector3.Up);
        beamInstance.RotateObjectLocal(Vector3.Right, Mathf.Pi / 2);
        beamInstance.Scale = new Vector3(1, distance, 1);

        // Verwijder na 0.05 seconden
        GetTree().CreateTimer(0.05).Timeout += () => beamInstance.QueueFree();
    }
}