Godot 4 Patterns

Patterns canoniques pour développer sur Godot 4.x (2026 LTS) avec GDScript 2 typé.

1. Scenes + Nodes — composition over inheritance

Player.tscn (CharacterBody2D)
├── CollisionShape2D
├── Sprite2D
├── AnimationPlayer
├── HealthComponent (Node, custom)
├── InventoryComponent (Node, custom)
└── HitboxComponent (Area2D, custom)

# Player.gd
extends CharacterBody2D
class_name Player

@export var speed: float = 300.0
@export var jump_velocity: float = -400.0

@onready var health: HealthComponent = $HealthComponent
@onready var inventory: InventoryComponent = $InventoryComponent
@onready var animation: AnimationPlayer = $AnimationPlayer

func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity.y += get_gravity().y * delta

    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = jump_velocity

    var direction := Input.get_axis("move_left", "move_right")
    velocity.x = direction * speed

    move_and_slide()

    _update_animation(direction)

func _update_animation(direction: float) -> void:
    if not is_on_floor():
        animation.play("jump")
    elif direction != 0:
        animation.play("run")
    else:
        animation.play("idle")

Pattern de composition : au lieu d'une grosse classe Player, on attache des composants (HealthComponent, InventoryComponent, HitboxComponent) qui exposent leur API via méthodes/signaux. Réutilisable sur Enemies, NPCs, Objects.

2. Signals (event-driven)

# HealthComponent.gd
extends Node
class_name HealthComponent

signal health_changed(new_health: int, max_health: int)
signal died

@export var max_health: int = 100
var current_health: int : set = _set_health

func _set_health(value: int) -> void:
    current_health = clamp(value, 0, max_health)
    health_changed.emit(current_health, max_health)
    if current_health <= 0:
        died.emit()

func take_damage(amount: int) -> void:
    current_health -= amount

func heal(amount: int) -> void:
    current_health += amount

# UI HUD subscribe au signal
func _ready() -> void:
    player.health.health_changed.connect(_on_health_changed)
    player.health.died.connect(_on_player_died)

func _on_health_changed(current: int, max_health: int) -> void:
    health_bar.value = float(current) / max_health * 100

3. Autoload singletons

Project Settings → Autoload → ajouter les scripts globaux :

# game_state.gd (autoload as "GameState")
extends Node

var current_score: int = 0
var current_level: int = 1
var player_data: PlayerData

signal score_changed(new_score: int)
signal level_completed

func add_score(amount: int) -> void:
    current_score += amount
    score_changed.emit(current_score)

func reset() -> void:
    current_score = 0
    current_level = 1

# Utilisation depuis n'importe quel script
func collect_coin() -> void:
    GameState.add_score(10)

Bons candidats autoload : GameState, AudioManager, SceneTransition, SaveLoadManager, EventBus.

Mauvais candidats : tout ce qui est spécifique à une scène ou un niveau.

4. Resources (data-driven)

# weapon_data.gd
extends Resource
class_name WeaponData

@export var weapon_name: String
@export var damage: int = 10
@export var fire_rate: float = 1.0
@export var icon: Texture2D
@export var fire_sound: AudioStream

Crée ensuite des .tres files dans l'éditeur :

• weapons/sword.tres (damage=15, fire_rate=2.0)
• weapons/bow.tres (damage=8, fire_rate=4.0)

# weapon.gd
extends Node
class_name Weapon

@export var data: WeaponData

func fire() -> void:
    print("Firing %s, damage %d" % [data.weapon_name, data.damage])

Équivalent direct des ScriptableObjects Unity — données éditables sans recompilation, partagées sans duplication.

5. Animation — AnimationPlayer + AnimationTree

# Pour une animation simple, AnimationPlayer suffit
animation.play("attack")
animation.queue("idle")  # joue idle après attack

# Pour state machine complexe, utiliser AnimationTree
@onready var animation_tree: AnimationTree = $AnimationTree
@onready var state_machine = animation_tree["parameters/playback"]

func _ready() -> void:
    animation_tree.active = true

func attack() -> void:
    state_machine.travel("attack")  # transition propre vers "attack"

6. Physics — CharacterBody2D / 3D

# CharacterBody2D pour les acteurs jouables (player, NPCs, ennemis)
extends CharacterBody2D

const SPEED = 300.0
const JUMP_VELOCITY = -400.0

func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity += get_gravity() * delta

    if Input.is_action_just_pressed("ui_accept") and is_on_floor():
        velocity.y = JUMP_VELOCITY

    var direction := Input.get_axis("ui_left", "ui_right")
    if direction:
        velocity.x = direction * SPEED
    else:
        velocity.x = move_toward(velocity.x, 0, SPEED)

    move_and_slide()

Type	Use case
CharacterBody2D/3D	Player, NPC, ennemis (control manuel)
RigidBody2D/3D	Objets physiques (boîtes, débris, projectiles)
StaticBody2D/3D	Plateformes, murs, sols
Area2D/3D	Triggers, hitboxes, pickups (no collision response)

7. Tilemap (level design 2D)

Godot 4 a refondu le système Tilemap. Workflow :

1. Créer une TileSet resource
2. Importer un atlas de tiles
3. Définir les TerrainSets pour autotile (sol, mur, eau)
4. Définir les Physics Layers pour la collision
5. Peindre dans la scène avec le TileMapLayer node

8. Export templates et plateformes

# Export depuis CLI
godot --export-release "Windows Desktop" build/windows/game.exe
godot --export-release "Linux/X11" build/linux/game.x86_64
godot --export-release "macOS" build/mac/game.zip
godot --export-release "Android" build/android/game.apk
godot --export-release "iOS" build/ios/game.ipa
godot --export-release "Web" build/web/index.html

Exports nécessaires : télécharger les Export Templates pour la version exacte de Godot via Editor → Manage Export Templates.

9. C# vs GDScript vs GDExtension

Langage	Use case
GDScript 2 typé	Default — 90% du gameplay
C#	Si l'équipe vient de Unity, utilisation des libs .NET, perf importante
GDExtension (C++)	Hot paths critiques (procedural mesh generation, physics custom, intégration libs C/C++)

GDScript 2 typé est étonnamment performant grâce au compilateur Godot. Privilégier les types explicites :

# BAD
var enemies = []
func add_enemy(e):
    enemies.append(e)

# GOOD
var enemies: Array[Enemy] = []
func add_enemy(e: Enemy) -> void:
    enemies.append(e)

10. Anti-patterns

1. get_node("$Path/With/Many/Slashes") partout — utiliser @onready var x = $Path ou export
2. Pas de typing — typage explicite Godot 4 améliore perf + erreurs détectées tôt
3. Logique dans _process au lieu de _physics_process pour les mouvements physiques
4. Pas de signals, polling à la place — préférer event-driven
5. process_mode = INHERIT sur tout → ralentit le pause global
6. Autoload pour des données spécifiques à une scène — pollution
7. Scene tree imbriquée 10 niveaux profonds — composition fragile
8. Pas de pre-import script sur les assets → reimport non-déterministe
9. Resource.duplicate(true) abusé → fuite mémoire
10. Pas de scènes additives — chargement scène monolithique long
11. set_physics_process(false) oublié sur entités hors écran — perf gâchée
12. GDScript dynamic sans typing en 2026 — hérité Godot 3, perf inférieure

Checklist livraison

• Godot 4.x (LTS quand dispo)
• Renderer choisi (Forward+ desktop, Mobile pour mobile)
• GDScript 2 typé partout
• Scenes décomposées en composants
• Signals utilisés au lieu de polling
• Autoloads minimaux et justifiés
• Resources pour les data
• Export templates installés
• Profiler pass régulier (Debugger → Profiler)
• Build pipelines (godot CLI + GitHub Actions)
• Tests via Gut framework

Quand déléguer

• Multiplayer Godot → skill game-multiplayer-patterns (ce plugin)
• Asset pipelines → skill game-asset-pipelines (ce plugin)
• Unity équivalent → skill unity-patterns (ce plugin)
• Architecture game → agent game-architect (ce plugin)
• Godot expert → agent godot-expert (ce plugin)

Ressources

• https://docs.godotengine.org/en/stable/
• https://github.com/godotengine/godot-demo-projects
• https://github.com/Donchitos/Claude-Code-Game-Studios (inspiration MIT)
• https://github.com/HubDev-AI/godot-ai-builder