Niveaux et courbe de difficulté : concevoir le contenu dans le GDD

Organisation du contenu : planifier les niveaux dans le GDD

Dans un GDD, la section « Niveaux et difficulté » sert à transformer vos mécaniques et votre progression en contenu jouable : combien de niveaux, ce que chaque niveau apprend au joueur, et comment la difficulté augmente sans devenir injuste. L’objectif est d’obtenir une progression lisible (pour l’équipe) et ressentie comme « naturelle » (pour le joueur).

1) Définir le nombre de niveaux et la durée cible

Commencez par fixer une enveloppe de contenu réaliste. Pour un petit jeu, une progression courte mais dense est préférable à une longue série de niveaux répétitifs.

• Nombre de niveaux : 8 à 15 niveaux est une bonne base pour un prototype abouti ou un petit jeu.
• Durée cible par niveau : définissez une durée « première réussite » (ex. 45–90 s) et une durée « maîtrise » (ex. 20–45 s).
• Durée totale : additionnez la durée cible + une marge d’échecs (ex. x1,5) pour estimer le temps de session.

2) Définir un objectif clair par niveau

Chaque niveau doit avoir un objectif principal unique, formulé comme une action observable. Évitez les objectifs vagues (« survivre ») sans métrique.

• Objectifs typiques : atteindre une sortie, collecter X objets, activer Y interrupteurs, escorter un élément, battre un mini-boss, réaliser un temps cible.
• Critère de réussite : condition binaire testable (ex. « sortie atteinte avec au moins 1 PV »).
• Critère d’échec : condition claire (ex. « PV = 0 » ou « temps > 120 s »).

3) Assurer variété et réutilisation d’éléments

La variété ne signifie pas « tout nouveau à chaque fois ». Dans un petit jeu, la réutilisation est une force si elle est structurée.

• Varier par paramètres : même obstacle, mais vitesse, cadence, fenêtre de timing, densité, ou ordre différent.
• Varier par contexte : même ennemi, mais dans un couloir étroit, avec un piège, ou avec une ressource limitée.
• Réutiliser par “blocs” : construisez une bibliothèque de segments (début, challenge, respiration, final) et recombinez-les.
• Limiter les nouveautés : idéalement 1 nouveauté majeure (ou 2 mineures) par niveau pour garder l’apprentissage fluide.

Méthode pratique (pas à pas) pour organiser 10 niveaux

1. Fixez la durée : ex. 60 s par niveau (première réussite), 30 s en maîtrise.
2. Listez 6–10 “blocs” réutilisables (tuiles/obstacles/ennemis/items) avec leurs paramètres (voir plus bas).
3. Choisissez 3–4 règles/compétences à enseigner (ex. dash, interrupteur, ennemi patrouilleur, piège timing).
4. Répartissez l’enseignement : introduction (niveau 1–3), combinaison (4–6), variation (7–8), maîtrise (9–10).
5. Attribuez un objectif par niveau + 1 contrainte (ex. temps, ressource, chemin unique).
6. Planifiez la “respiration” : un niveau plus court ou plus simple après un pic de difficulté.

Conception de la courbe de difficulté : introduire, combiner, varier, maîtriser

Une courbe de difficulté efficace est une courbe d’apprentissage. Le joueur progresse parce qu’il comprend et exécute mieux, pas uniquement parce que les chiffres augmentent.

Continuez dans notre application.

Vous pouvez écouter le livre audio écran éteint, recevoir un certificat gratuit pour ce cours et accéder également à 5 000 autres cours en ligne gratuits.

Ou poursuivez votre lecture ci-dessous...

Téléchargez l'application

1) Introduction d’une règle (apprentissage guidé)

But : faire découvrir une règle ou un élément avec un risque faible.

• Isoler la nouveauté : un seul nouvel obstacle/ennemi à la fois.
• Rendre l’échec peu coûteux : checkpoint proche, pénalité légère.
• Donner un signal clair : télégraphie visuelle/sonore (ex. animation avant attaque).

2) Combinaison (complexité contrôlée)

But : faire utiliser deux règles ensemble. La difficulté vient de la coordination, pas de la surprise.

• Combiner 2 éléments max au début (ex. ennemi + piège), puis 3 plus tard.
• Réduire l’aléatoire : patterns stables pour que le joueur puisse apprendre.
• Ajouter une contrainte : espace réduit, timing plus serré, ressource limitée.

3) Variation (même règle, nouveau contexte)

But : prouver la compréhension en changeant le décor du problème.

• Changer l’ordre : piège puis ennemi, au lieu de l’inverse.
• Changer l’échelle : plus long segment, ou micro-segments répétés.
• Changer la lecture : visibilité réduite, bifurcation, leurre.

4) Maîtrise (test final lisible)

But : demander une exécution fiable, sans introduire de nouveauté majeure.

• Pas de nouvelle règle : uniquement des combinaisons déjà vues.
• Pic de difficulté : densité plus élevée, mais toujours télégraphiée.
• Objectif “propre” : temps cible, zéro dégât, ou collecte complète (optionnel).

Indicateurs concrets pour calibrer la difficulté

Blocs de niveau : tuiles, obstacles, ennemis, items

Pour documenter vos niveaux efficacement, décrivez des « blocs » (building blocks) réutilisables. Un bloc est un élément de gameplay + ses paramètres + ses règles de placement. Cela permet de construire vite, de tester vite, et de garder une cohérence.

1) Fiche type d’un bloc (format GDD)

Bloc_ID: (ex. OBS_SPIKES_01)  Catégorie: Obstacle / Ennemi / Item / Tuile interactive / Décor bloquant / Trigger
Description: ce que fait le bloc en 1 phrase
Rôle: apprentissage / pression / punition / récompense / rythme
Paramètres: valeurs modifiables (vitesse, dégâts, cooldown, portée, etc.)
Télégraphie: indices avant activation (animation, son, particules)
Règles de placement: contraintes (distance min, pas près du spawn, etc.)
Interactions: avec quelles règles/objets il se combine
Variantes: versions A/B (plus rapide, plus large, etc.)

2) Exemples de blocs (concrets et réutilisables)

• Tuile “Sol fragile” : se casse après 0,6 s de contact. Paramètres : délai, temps de respawn, nombre d’utilisations. Placement : jamais sur le chemin unique si chute = mort instantanée (sauf niveau maîtrise).
• Obstacle “Pics” : dégâts élevés, télégraphie faible (statique). Paramètres : dégâts, largeur, position. Placement : toujours visible avant le saut, distance min après un checkpoint.
• Ennemi “Patrouilleur” : va-et-vient sur une plateforme. Paramètres : vitesse, longueur de patrouille, temps de pause. Placement : éviter de le mettre sur une plateforme déjà “timing” (sinon surcharge) avant les niveaux de combinaison.
• Item “Clé” : ouvre une porte. Paramètres : nombre de clés, porte associée, feedback. Placement : la clé doit être visible ou indiquée par un chemin lisible.

3) Paramètres et règles de placement (checklist)

• Distances minimales : entre menaces, entre checkpoint et première menace, entre item et danger.
• Zones interdites : zone de spawn, zone de tutoriel implicite, zone de sortie.
• Lisibilité : la menace doit être identifiable avant d’exiger une réaction (sauf piège “surprise” explicitement annoncé et rare).
• Compatibilités : quelles combinaisons sont autorisées (ex. patrouilleur + plateforme étroite seulement à partir du niveau 5).
• Rythme : alterner segments de pression et segments de respiration (ex. 10–20 s de challenge puis 5–10 s plus calmes).

Documentation dans le GDD : tableau des niveaux et schémas de layout

1) Modèle de tableau de niveaux (livrable)

Ce tableau est le cœur de la documentation de contenu. Il permet de suivre la progression, d’éviter les doublons, et de donner une base claire à la production.

Conseil de remplissage : dans « Nouveautés », notez uniquement ce qui est nouveau pour le joueur (règle, ennemi, contrainte). Dans « Blocs utilisés », référencez des IDs de blocs (ex. OBS_SPIKES_01) plutôt que des descriptions longues.

2) Schémas de layout : comment les documenter

Un schéma de layout n’a pas besoin d’être artistique. Il doit expliquer la structure : segments, checkpoints, menaces, items, chemins. Deux formats simples à inclure dans un GDD :

• Schéma ASCII (rapide, lisible dans un document texte).
• Schéma “boîtes et flèches” (segments numérotés : S1, S2, S3… avec type : intro/challenge/respiration/final).

Exemple de schéma ASCII (vue de côté simplifiée) :

Spawn -> [S1: intro] --(gap)-- [S2: challenge] -- [CP] -- [S3: combo] -> Exit
           item?             spikes         checkpoint    enemy+spikes

Exemple de schéma par segments :

S1 (Intro, 10s): mouvement simple, 0 menace
S2 (Challenge, 20s): OBS_SPIKES_01 x2, timing lent
CP
S3 (Combo, 25s): EN_PATROL_01 + OBS_SPIKES_01, espace moyen
S4 (Final, 10s): sprint vers sortie

Exemple de progression sur 10 niveaux (livrable)

Exemple générique pour un petit jeu 2D à niveaux courts, basé sur 4 éléments : OBS_SPIKES_01 (pics), EN_PATROL_01 (patrouilleur), SW_SWITCH_01 (interrupteur), IT_KEY_01 (clé). Adaptez les noms à votre jeu, mais gardez la logique : introduction → combinaison → variation → maîtrise.

Étapes pour adapter cet exemple à votre jeu (procédure)

1. Remplacez les blocs par ceux de votre jeu (listez 6–12 blocs max).
2. Attribuez une “fonction pédagogique” à chaque niveau : intro / combo / variation / maîtrise.
3. Fixez une seule nouveauté par niveau (ou une nouveauté mineure + une contrainte légère).
4. Définissez 1–2 contraintes récurrentes (temps, ressource, checkpoints) et faites-les monter progressivement.
5. Documentez un schéma par niveau (ASCII ou segments) pour rendre la production et le test immédiats.