🎲 Godot 4 – Moteur de Jeu Open Source (GDScript, C#)

Godot est portable. Il n'y a pas d'installateur (contrairement à Unity Hub). Vous téléchargez un binaire unique (un .exe ou binaire Linux) et vous l'exécutez.

Le "Project Manager" (gestionnaire de projets) est intégré au binaire de l'éditeur.

Les Deux Versions (Godot 4)

Sur la page de téléchargement (godotengine.org), vous devez choisir entre deux versions :

Philosophie (Tout est un Nœud)

Dans Godot, la philosophie est basée sur l'Héritage et la Composition via un Arbre de Nœuds (Node Tree).

L'arborescence des Nœuds est basée sur l'Héritage (C++). Choisir le bon nœud de base est crucial.

Node (Le "père" de tout)
  └ (Logique pure, timers, requêtes HTTP...)
  
  ├─ Node2D (Base pour la 2D)
  │  (A un Transform2D : position, rotation, scale)
  │  ├─ Sprite2D (Visuel)
  │  ├─ Camera2D
  │  ├─ PhysicsBody2D (Base Physique 2D)
  │  │  ├─ CharacterBody2D (Joueur)
  │  │  ├─ StaticBody2D (Sol, Murs)
  │  │  └─ RigidBody2D (Objets)
  │  └─ Area2D (Trigger / Zone)
  │
  ├─ Node3D (Base pour la 3D)
  │  (A un Transform3D : position, rotation, scale)
  │  ├─ MeshInstance3D (Visuel)
  │  ├─ Camera3D
  │  ├─ PhysicsBody3D (Base Physique 3D)
  │  │  ├─ CharacterBody3D (Joueur)
  │  │  ├─ StaticBody3D (Sol, Murs)
  │  │  └─ RigidBody3D (Objets)
  │  └─ Area3D (Trigger / Zone)
  │
  └─ Control (Base pour l'UI)
     (A un RectTransform : ancres, marges)
     ├─ Label (Texte)
     ├─ Button (Bouton)
     ├─ Panel (Fond)
     └─ VBoxContainer (Layout)

C'est la Philosophie de Composition de Godot. (L'équivalent du "Prefab" d'Unity, mais en plus flexible).

Principe : N'importe quel fichier Scène (.tscn) peut être utilisé comme un Nœud (Node) à l'intérieur d'une autre Scène.

Workflow

1. Scène 1 (Player.tscn) :

   CharacterBody2D (Root)
     ├ Sprite2D
     └ CollisionShape2D

2. Scène 2 (Bullet.tscn) :

   Area2D (Root)
     ├ Sprite2D
     └ CollisionShape2D

3. Scène 3 (Level.tscn) :

   Node2D (Root)
     ├ (Instance de "Player.tscn")
     └ TileMap (Le décor)

Instanciation (Script)

Pour faire "spawner" une balle (Scène "Bullet") depuis le Joueur (Scène "Player").

(Dans Player.gd)
extends CharacterBody2D

# 1. Pré-charger la Scène (Asset)
var bullet_scene = preload("res://Bullet.tscn")

func _physics_process(delta):
    if Input.is_action_just_pressed("ui_accept"):
        # 2. Instancier la scène
        var bullet_instance = bullet_scene.instantiate()
        
        # 3. Ajouter l'instance à l'arbre de la scène
        # (Sinon elle n'existe pas dans le jeu)
        get_tree().root.add_child(bullet_instance)
        
        # 4. Configurer (ex: position)
        bullet_instance.global_position = self.global_position

GDScript est le langage de scripting principal de Godot. C'est un langage haut niveau, orienté objet, conçu pour être simple et profondément intégré au moteur.

Caractéristiques

• Syntaxe (Python-like) : Utilise l'indentation (pas d'accolades {} ni de ;). (Très facile à apprendre).
• Léger : Intégré directement, pas de "glue" (contrairement à C#).
• Typage Optionnel (Statique/Dynamique) :
  • Dynamique (Legacy) : var vitesse = 100
  • Statique (Godot 3+/4, Recommandé) : var vitesse: int = 100 (Permet l'auto-complétion).

Exemple de Script (Player.gd)

# 1. Héritage (le Nœud auquel ce script est attaché)
extends CharacterBody2D

# 2. Variables (Membres)
var speed: int = 300
var gravity: int = 800

# 3. (Optionnel) Référence "exportée" (visible dans l'Inspecteur)
@export var message: String = "Bonjour"

# 4. Cycle de vie (_ready = Start)
func _ready():
    # 'position' est hérité de Node2D
    print("Le Joueur est prêt à : ", position)

# 5. Cycle de vie (_physics_process = FixedUpdate)
func _physics_process(delta):
    # Appliquer la gravité
    velocity.y += gravity * delta
    
    # Gérer les inputs (voir 5.3)
    var input_x = Input.get_axis("ui_left", "ui_right")
    velocity.x = input_x * speed
    
    # Appliquer le mouvement
    move_and_slide()

Godot (comme Unity) appelle des fonctions "magiques" (callbacks) sur vos scripts (Nœuds) à des moments précis.

Godot (via la version .NET) a un support officiel pour C# (sur .NET 6+). C'est une alternative à GDScript, souvent préférée par les développeurs venant d'Unity ou ceux préférant le typage statique robuste de C#.

Fonctionnement

• Héritage : (Similaire à GDScript) Votre script C# doit hériter d'un type de Nœud Godot (ex: public partial class Player : CharacterBody2D).
• partial class : (Nouveau dans Godot 4) Godot utilise des "Source Generators" (Générateurs de Source) pour la "magie" (binding C# <-> C++), nécessitant que les classes de Nœud soient partial.
• IDE : Le code est édité dans un IDE externe (VS Code, Visual Studio, Rider). Godot gère la solution (.sln) et la compilation.

Le cycle de vie C# est identique à GDScript, mais en syntaxe C# (PascalCase).

La syntaxe C# utilise des Attributs ([]) là où GDScript utilise @.

using Godot;

public partial class Player : CharacterBody2D
{
    // 1. Export (Variables d'Inspecteur)
    [Export]
    public int Speed { get; set; } = 400;

    [Export]
    private NodePath _spritePath;
    
    private Sprite2D _sprite;

    // 2. Cycle de vie (_Ready)
    public override void _Ready()
    {
        // 3. Accès aux Nœuds (GetNode) (Pas de '$')
        _sprite = GetNode<Sprite2D>(_spritePath);
        
        // 4. Connexion aux Signaux (code)
        // (Connecte le signal "pressed" du Nœud "MyButton"
        //  à la méthode "OnMyButtonPressed" de cet objet)
        GetNode("MyButton").Connect("pressed", 
            new Callable(this, nameof(OnMyButtonPressed)));
    }

    // 5. Définition d'un Signal (perso)
    [Signal]
    public delegate void HealthChangedEventHandler(int newHealth);

    // 6. Émission d'un Signal
    private void TakeDamage(int amount)
    {
        // ... (logique)
        EmitSignal(nameof(HealthChanged), 80);
    }
    
    // 7. Fonction (Callback)
    private void OnMyButtonPressed()
    {
        GD.Print("Bouton pressé !");
    }
}

Les nœuds de physique 2D (séparés de la 3D).

Les nœuds de physique 3D (séparés de la 2D).

Godot utilise un Input Map (Mappage d'Entrées) (Project > Project Settings > Input Map) pour abstraire les entrées. C'est l'équivalent de l'ancien "Input Manager" d'Unity.

Configuration (Input Map)

Vous créez des "Actions" (Noms) et vous y "bindez" (liez) des touches/boutons.

Action: "move_right"
  -> Key: D
  -> Key: Right Arrow
  -> Joypad: (Left Stick Right)
  
Action: "jump"
  -> Key: Space
  -> Joypad: (Button A)

Scripting (GDScript)

On utilise Input (un Singleton global) pour vérifier ces Actions.

func _physics_process(delta):
    var direction = 0

    # --- Polling (Dans _process) ---
    
    # Action (Axe)
    # (Combine -1 (left) et +1 (right) en 1 seul axe)
    direction = Input.get_axis("ui_left", "ui_right")

    # Action (Booléen)
    # (Juste pressé)
    if Input.is_action_just_pressed("jump"):
        velocity.y = JUMP_FORCE
        
    # (Maintenu)
    if Input.is_action_pressed("sprint"):
        speed = SPRINT_SPEED

Événement (_input)

Alternative (event-based) à _process. Recommandé pour les actions "pressées" (ex: Tirer).

func _input(event):
    if event.is_action_pressed("fire_bullet"):
        fire()
    
    if event is InputEventMouseButton:
        if event.button_index == MOUSE_BUTTON_LEFT:
            print("Clic gauche !")

Godot 4 a été une réécriture majeure du moteur de rendu (Rendering Engine).

L'objectif est d'offrir une haute fidélité (similaire à UE/Unity HDRP) tout en restant performant sur des plateformes plus modestes.

L'interface utilisateur (UI) dans Godot est gérée par un type de nœud spécial : Control.

Les nœuds Control (ex: Button, Label, Panel) sont conçus pour être utilisés ensemble. Ils s'ancrent et se positionnent (responsive) les uns par rapport aux autres (via les Containers).

Nœuds Control (Courants)

• Control : Le nœud Control de base (agit comme un div vide).
• CanvasLayer : (Racine UI) Un nœud (non-Control) qui dessine l'UI par-dessus le jeu 2D/3D (fixe à l'écran).
• Panel / PanelContainer : Un fond (background) coloré.
• Label : Affiche du texte.
• Button : Un bouton (émet le signal pressed()).
• LineEdit : Champ de saisie (Input text).

Containers (Layout)

Les "Containers" sont des nœuds Control qui arrangent automatiquement leurs enfants (évite le positionnement manuel) :

• VBoxContainer : Aligne les enfants verticalement.
• HBoxContainer : Aligne les enfants horizontalement.
• GridContainer : Aligne les enfants en grille.

Le processus d'exportation (Project > Export...) de Godot est très simple, mais nécessite des Export Templates (Modèles d'Exportation).

1. Télécharger les Templates

Pour exporter, vous devez d'abord télécharger les "Templates" (les "binaires" précompilés pour chaque plateforme) correspondant à votre version de Godot (ex: 4.2.1).

2. Configurer le "Preset" (Pré-réglage)

Dans la fenêtre d'Export, vous ajoutez un "Preset" (ex: "Windows Desktop").

Options (Exemple Windows) :

• Binary (Binaire) : .exe (Jeu) + .pck (Données/Assets). (Ou Embed PCK pour 1 seul .exe).
• Icon : L'icône du .exe.
• Version Info : (Copyright, Nom...).

Export (Android/iOS)

L'export mobile nécessite une configuration plus complexe :

• Android : Nécessite le SDK Android, JDK (Java), et une Keystore (clé de signature).
• iOS : (Nécessite un Mac) Godot génère un projet Xcode, que vous devez ensuite compiler et signer avec Xcode.