2. Player Character

Bouw een 3D platformer character met movement, jumping en follow camera

Overzicht

In dit hoofdstuk bouw je de player character voor je platformer. Je maakt een CharacterBody3D met WASD movement, jump mechanics, en een simpele follow camera die de player volgt. In het volgende hoofdstuk voegen we camera rotation toe.

Player scene maken

Maak een Player-scene met een CharacterBody3D als root node. Dit is het physics body waar het movement script op komt. Het character model voeg je daarna toe als child.

1. Ga in de menu naar Scene > New Scene

2. Selecteer Other Node en zoek naar CharacterBody3D

3. Klik Create

4. Hernoem de root node naar Player

5. Selecteer de Player node en voeg een CollisionShape3D child toe (rechts-klik > Add Child Node)

6. Kies voor een CapsuleShape3D

7. Sla de scene op als res://objects/Player.tscn

Player scene hierarchy:

Player (CharacterBody3D)
└── CollisionShape3D (CapsuleShape3D)

Character model toevoegen

Voeg nu het character model toe als child van de CharacterBody3D.

1. In de Player.tscn scene, open het FileSystem panel

2. Navigeer naar models/character.glb

3. Sleep character.glb naar de Player node in de Scene hierarchy

4. Het model wordt nu als child toegevoegd onder Player

5. Selecteer de collisionShape3D

6. Gebruik de rode handles om de capsuleCollider aan het character te laten passen

7. Sla de scene op

Player scene hierarchy (updated)

Player (CharacterBody3D)
├── CollisionShape3D (CapsuleShape3D)
└── character (imported scene from character.glb)

Voeg de player toe aan de main scene

1. open scenes/main.tscn

2. Sleep vanuit het FileSystem het object objects/player.tscn in de scene

3. Gebruik de move tool om de speler op een platform te zetten

4. Sla de scene op

View node (camera container)

Voor een platformer maak je een follow camera die de player volgt. Maak een aparte View node die later uitgebreid kan worden met camera rotation.

1. Open scenes/main.tscn

2. Rechts-klik op de Main root node > Add Child Node

3. Kies Node3D en hernoem naar View

Belangrijk! Plaats de View Node op DEZELFDE locatie als de speler

Camera3D Node Toevoegen

De View node heeft dan uiteraard een camera nodig.

1. Open scenes/main.tscn

2. Selecteer de View node

3. Rechts-klik > Add Child Node > Camera3D

4. BELANGRIJK: Gebruik de Move Tool om de camera boven-en-achter de speler te plaatsen

Scene hierarchy in main.tscn:

Main (Node)
├── Sun (DirectionalLight3D)
├── Environment (WorldEnvironment)
├── World (Node3D)
│   └── ... (platforms)
├── View (Node3D) [View script]
│   └── Camera3D
└── Player (instanced scene - Player.tscn)

View node script

1. Selecteer de View node en klik op Attach Script

   • Language: C#

   • Template: Empty (geen template)

   • Class Name: View

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

2. Klik Create

3. Open scripts/View.cs en voeg variabelen toe voor de target (player), camera, en follow speed:

using Godot;

public partial class View : Node3D
{
    [Export] private Node3D _target; // De player
    [Export] private Camera3D _camera; // De camera
    [Export] private float _followSpeed = 5.0f;
}

1. Voeg de _PhysicsProcess() method toe. Gebruik Lerp() voor smooth camera movement (linear interpolation):

using Godot;

public partial class View : Node3D
{
    [Export] private Node3D _target;
    [Export] private Camera3D _camera;
    [Export] private float _followSpeed = 5.0f;

    public override void _PhysicsProcess(double delta)
    {
        if (_target == null) return;

        // Smooth follow naar player positie
        GlobalPosition = GlobalPosition.Lerp(_target.GlobalPosition, _followSpeed * (float)delta);
    }
}

De camera en speler toewijzen

• Selecteer de View node in de Inspector

• Sleep de Camera3D node naar het Camera veld

• Sleep de Player node naar het Target veld

Player script toevoegen

Voeg nu een script toe aan de CharacterBody3D root.

1. Selecteer de Player (CharacterBody3D) root node

2. Klik op Attach Script (📜+ icoon bovenaan Scene venster)

   • Language: C#

   • Template: CharacterBody3D: Basic Movement

   • Class Name: Player

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

3. Klik Create

Het script opent in VS Code met een basis movement template voor CharacterBody3D.

Template aanpassingen

De template gebruikt const voor speed en jump velocity, en verwijst naar de verkeerde input actions. Pas dit aan.

1. Open scripts/Player.cs en verander const variabelen naar [Export] variabelen. Met [Export] zijn de variabelen aanpasbaar in de Inspector. Gebruik F2 om de naam te wijzigen in het hele bestand:

using Godot;

public partial class Player : CharacterBody3D
{
    [Export] private float _speed = 5.0f;
    [Export] private float _jumpVelocity = 8.0f;

    // ... rest van de code
}

1. Zoek in _PhysicsProcess() naar de regel met Input.GetVector() en pas de input actions aan naar onze input map:

// Get the input direction
Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");

1. Pas de jump action aan van ui_accept naar jump:

// Handle Jump
if (Input.IsActionJustPressed("jump") && IsOnFloor())
{
    velocity.Y = _jumpVelocity;
}

Character animaties

Het character model bevat een AnimationPlayer met drie animaties: idle, walk, en jump. Om deze te kunnen gebruiken moet je eerst de children van het geïmporteerde model toegankelijk maken.

1. Open objects/Player.tscn

2. Selecteer de character2 node (het geïmporteerde model)

3. Rechts-klik op de character2 node > Editable Children

4. De character2 node klapt nu open en je ziet de interne structuur, inclusief de AnimationPlayer

Player scene hierarchy (updated)

Player (CharacterBody3D)
├── CollisionShape3D (CapsuleShape3D)
└── character2
    ├── character
    │   └── root
    │       ├── leg-left
    │       ├── leg-right
    │       └── torso
    │           ├── arm-left
    │           ├── arm-right
    │           └── antenna
    └── AnimationPlayer

Animatie logic

Speel nu de animaties af op basis van de player state. Bouw dit stap voor stap op in een aparte method.

1. Open scripts/Player.cs en voeg eerst de AnimationPlayer variabele toe:

using Godot;

public partial class Player : CharacterBody3D
{
    [Export] private float _speed = 5.0f;
    [Export] private float _jumpVelocity = 8.0f;
    [Export] private AnimationPlayer _animationPlayer;

    // ... rest van de code
}

1. Maak een nieuwe method UpdateAnimation() onderaan de class. Begin met alleen de idle animatie:

    private void UpdateAnimation(Vector3 direction)
    {
        if (_animationPlayer == null) return;

        // Speel idle animatie
        _animationPlayer.Play("idle");
    }

1. Roep deze method aan onderaan _PhysicsProcess(), na MoveAndSlide():

    public override void _PhysicsProcess(double delta)
    {
        // ... movement code ...

        Velocity = velocity;
        MoveAndSlide();

        // Update animaties
        UpdateAnimation(direction);
    }

1. Voeg de walk animatie toe wanneer de player beweegt:

    private void UpdateAnimation(Vector3 direction)
    {
        if (_animationPlayer == null) return;

        if (direction != Vector3.Zero)
        {
            _animationPlayer.Play("walk");
        }
        else
        {
            _animationPlayer.Play("idle");
        }
    }

1. Voeg als laatste de jump animatie toe. De jump heeft prioriteit boven walk/idle:

    private void UpdateAnimation(Vector3 direction)
    {
        if (_animationPlayer == null) return;

        // Jump heeft prioriteit (in de lucht)
        if (!IsOnFloor())
        {
            _animationPlayer.Play("jump");
        }
        // Beweegt op de grond
        else if (direction != Vector3.Zero)
        {
            _animationPlayer.Play("walk");
        }
        // Staat stil op de grond
        else
        {
            _animationPlayer.Play("idle");
        }
    }

1. Ga terug naar objects/Player.tscn in de editor

2. Selecteer de Player root node

3. In de Inspector, vind het Animation Player veld (onder de Script Parameters)

4. Sleep de AnimationPlayer node vanuit de scene hierarchy naar dit veld

5. Sla de scene op

Test de player en camera

1. Open scenes/main.tscn

2. Zorg dat de View node correct is ingesteld:

   • Target veld: Sleep Player node hierheen

   • Camera veld: Sleep Camera3D child node hierheen

3. Run de scene (F5)

4. Test:

   • WASD - move player in world-space directions

   • Space - spring

   • Camera volgt de player smooth

Waarschuwing: De camera kan momenteel niet draaien - je beweegt in world-space richtingen! In het volgende hoofdstuk voegen we camera rotation toe zodat WASD relatief wordt aan je kijkrichting.

Complete scripts

Klik hier voor de volledige Player.cs en View.cs scripts

Player.cs

using Godot;

public partial class Player : CharacterBody3D
{
    [Export] private float _speed = 5.0f;
    [Export] private float _jumpVelocity = 8.0f;
    [Export] private AnimationPlayer _animationPlayer;

    public override void _PhysicsProcess(double delta)
    {
        Vector3 velocity = Velocity;

        // Gravity
        if (!IsOnFloor())
        {
            velocity += GetGravity() * (float)delta;
        }

        // Jump
        if (Input.IsActionJustPressed("jump") && IsOnFloor())
        {
            velocity.Y = _jumpVelocity;
        }

        // Input
        Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");

        // World-space movement
        Vector3 direction = new Vector3(inputDir.X, 0, inputDir.Y).Normalized();

        // Movement
        if (direction != Vector3.Zero)
        {
            velocity.X = direction.X * _speed;
            velocity.Z = direction.Z * _speed;
        }
        else
        {
            velocity.X = Mathf.MoveToward(Velocity.X, 0, _speed);
            velocity.Z = Mathf.MoveToward(Velocity.Z, 0, _speed);
        }

        Velocity = velocity;
        MoveAndSlide();

        // Update animaties
        UpdateAnimation(direction);
    }

    private void UpdateAnimation(Vector3 direction)
    {
        if (_animationPlayer == null) return;

        // Jump heeft prioriteit (in de lucht)
        if (!IsOnFloor())
        {
            _animationPlayer.Play("jump");
        }
        // Beweegt op de grond
        else if (direction != Vector3.Zero)
        {
            _animationPlayer.Play("walk");
        }
        // Staat stil op de grond
        else
        {
            _animationPlayer.Play("idle");
        }
    }
}

View.cs

using Godot;

public partial class View : Node3D
{
    [Export] private Node3D _target;
    [Export] private Camera3D _camera;
    [Export] private float _followSpeed = 5.0f;

    public override void _PhysicsProcess(double delta)
    {
        if (_target == null) return;

        // Smooth follow naar player positie
        GlobalPosition = GlobalPosition.Lerp(_target.GlobalPosition, _followSpeed * (float)delta);
    }
}