Gaming > Guide > Créer les premières mécaniques de gameplay dans Unreal Engine 5

Créer ses premières mécaniques de gameplay : donner un objectif à son prototype Gaming dans Unreal Engine 5

Créer une mécanique de gameplay consiste à relier une action du joueur, une règle et une conséquence observable. Dans Unreal Engine 5, les Blueprints permettent de construire ces relations visuellement. Après avoir préparé un environnement, un personnage et une première interaction, l’étape suivante est de donner une raison de parcourir la scène.

🗓️ Mis à jour le 3 novembre 2026

Ce sixième épisode propose un objectif accessible : collecter trois objets dans la cour, puis rejoindre une zone d’arrivée. Le personnage conserve la progression, les objets disparaissent lorsqu’ils sont ramassés et l’arrivée vérifie que la condition de réussite est remplie.

Nous utiliserons le projet Third Person en Blueprint des épisodes précédents, avec BP_PersonnageCour comme personnage jouable. Aucun code C++ ni ressource extérieure n’est nécessaire. L’exercice concerne un prototype solo : il ne met pas en place un inventaire complet, une sauvegarde de partie ou une gestion multijoueur.

Transformer une interaction en boucle de gameplay

Une lampe qui réagit au passage du personnage constitue une interaction. Pour construire un petit jeu, il faut également définir ce que le joueur cherche à accomplir et comment le système reconnaît sa progression.

Notre boucle comporte trois étapes : explorer la cour, ramasser les objets et atteindre l’arrivée. Chaque collecte rapproche le joueur de son objectif. La zone finale donne une conclusion à ce parcours.

Avant d’ouvrir les graphes, formulez les règles : chaque objet compte une fois, le total commence à zéro et trois collectes sont nécessaires. Entrer trop tôt dans l’arrivée ne valide pas la réussite.

Ces règles sont des choix pour cet exercice, pas des obligations imposées par Unreal Engine. Elles permettent de comprendre comment une expérience Gaming prend forme à partir de comportements simples.

Répartir les responsabilités entre trois Blueprints

Nous utiliserons trois éléments. BP_PersonnageCour conserve la progression du joueur. BP_ObjetCollectable représente un objet à ramasser. BP_ZoneArrivee vérifie le passage dans la zone finale.

Cette répartition permet de savoir où chercher lorsqu’un problème apparaît. Une collecte incorrecte concerne d’abord l’objet et le compteur ; une réussite déclenchée trop tôt concerne la vérification de l’objectif.

Pour ce prototype, conserver les valeurs dans le personnage est un choix simple. Elles appartiennent toutefois à cette instance : recréer le personnage ne garantit pas leur conservation.

Un projet plus développé peut répartir autrement les données selon leur rôle et leur durée de vie. Ici, gardez une structure réduite que vous pouvez expliquer.

Vérifiez avant de commencer que le GameMode utilise bien BP_PersonnageCour et que le personnage se déplace correctement dans la cour.

Préparer les variables de progression

Ouvrez BP_PersonnageCour. Dans My Blueprint, créez NombreObjetsCollectes de type Integer, avec une valeur par défaut de 0.

Ajoutez NombreObjetsRequis, également Integer, avec une valeur par défaut de 3. Ce second nombre représente notre objectif de collecte.

Créez enfin ObjectifValide de type Boolean, avec une valeur initiale False. Il permettra de mémoriser la réussite pendant la session et d’éviter de la déclencher plusieurs fois.

Compilez pour accéder aux valeurs par défaut, puis enregistrez. Laissez ces variables non privées si vous souhaitez les consulter depuis les autres Blueprints de l’exercice.

La documentation des variables Blueprint explique les types et la distinction entre Get, qui lit une valeur, et Set, qui la modifie.

Ne changez pas la valeur par défaut du compteur pour simuler une collecte : nous allons la modifier pendant le jeu.

Créer une fonction pour ajouter une collecte

Dans BP_PersonnageCour, créez une fonction appelée AjouterObjet. Elle regroupera la mise à jour du compteur.

Placez Get NombreObjetsCollectes, reliez sa valeur à une addition entière avec 1, puis transmettez le résultat à Set NombreObjetsCollectes. Connectez l’entrée d’exécution de la fonction au Set.

Ajoutez ensuite Print String pour afficher le nouveau total. Vous pouvez utiliser une conversion du nombre en chaîne et Append pour composer un message comme « Objets collectés : 1 ».

Ce message sert à contrôler le fonctionnement dans l’éditeur. Il ne constitue pas encore une interface de jeu définitive.

La documentation des fonctions Blueprint décrit ces graphes appelables depuis d’autres graphes. Nous utiliserons cette fonction pour éviter de recopier la mise à jour du compteur dans chaque objet.

Construire un objet collectable identifiable

Créez une Blueprint Class dérivée d’Actor et nommez-la BP_ObjetCollectable. Ajoutez un Static Mesh pour son apparence et un Sphere Collision pour sa détection.

Nommez les composants Visuel et ZoneCollecte. Choisissez une forme simple disponible dans le projet, puis ajustez sa taille pour qu’elle reste visible dans la cour.

Réglez la collision du composant Visuel sur NoCollision. La détection passera par ZoneCollecte, ce qui évite que l’apparence de l’objet bloque le personnage.

Pour ZoneCollecte, choisissez Query Only, activez Generate Overlap Events et configurez une réponse Overlap au canal Pawn, en ignorant les autres canaux.

Vérifiez également la génération des événements sur la capsule du personnage. Les deux composants concernés doivent la permettre.

Ajoutez dans ce Blueprint un Boolean nommé DejaCollecte, initialisé à False. Il servira à protéger la collecte contre une répétition.

Reconnaître le personnage qui touche l’objet

Sélectionnez ZoneCollecte et ajoutez On Component Begin Overlap depuis les événements du composant.

Reliez Other Actor à l’entrée Object d’un Cast To BP_PersonnageCour. Sur la sortie de réussite du cast, vous disposez d’une référence vers le personnage.

Le cast vérifie que l’objet reçu est compatible avec cette classe. Il ne crée pas un nouveau personnage et ne transforme pas un autre acteur en joueur. Epic explique ce mécanisme dans son guide sur le casting.

Depuis la référence obtenue, récupérez Get Capsule Component. Comparez cette capsule à Other Comp avec une égalité d’objets et utilisez le résultat dans un Branch.

La sortie True poursuit la collecte. La sortie False reste sans action. Ce filtrage retient la capsule plutôt qu’un autre composant susceptible de chevaucher la sphère.

Compter l’objet une seule fois, puis le supprimer

Sur le chemin validé, ajoutez un Branch utilisant Get DejaCollecte. Laissez True sans action et utilisez False pour poursuivre.

Reliez cette sortie à Set DejaCollecte avec la valeur True. Appelez ensuite AjouterObjet sur la référence du personnage obtenue par le cast.

Terminez la chaîne par Destroy Actor, avec Self comme cible : c’est l’objet collectable qui doit disparaître, pas le personnage.

L’ordre est essentiel : verrouiller la collecte, mettre à jour la progression, puis supprimer l’objet. La référence Destroy Actor décrit la destruction de l’acteur ciblé.

Compilez et enregistrez. Placez un exemplaire dans la cour, lancez Play et ramassez-le. Le total doit passer à 1 et l’objet disparaître.

Arrêtez ensuite la session : cet exemplaire reste présent dans le niveau enregistré pour les prochains essais.

Disposer trois objets dans un parcours lisible

Dupliquez l’instance pour obtenir trois objets collectables. Ils partagent la même classe, mais chaque exemplaire possède son propre état DejaCollecte.

Gardez les sphères de détection séparées pour faciliter les premiers tests. Placez un objet près du départ, un autre après un obstacle et le dernier à proximité de la plateforme.

Ces positions sont une proposition de parcours. Leur intérêt est d’amener le joueur à utiliser les déplacements déjà préparés : avancer, contourner et sauter.

Ne cachez pas immédiatement les objets dans des endroits difficiles à lire. Vous devez d’abord vérifier la mécanique avant d’évaluer un défi d’exploration.

Pour un prototype Gaming, un parcours court fournit déjà des informations utiles : les objectifs sont-ils visibles, accessibles et suffisamment espacés pour distinguer chaque collecte ?

Construire une zone d’arrivée distincte

Créez BP_ZoneArrivee à partir d’Actor. Ajoutez un Box Collision appelé ZoneValidation et, si nécessaire, un Static Mesh pour matérialiser l’arrivée.

Réglez la collision du visuel sur NoCollision. Configurez la boîte comme une zone de détection : Query Only, Generate Overlap Events actif et Overlap sur Pawn.

Placez l’arrivée au bout du parcours, dans un espace dégagé. Une forme et une couleur distinctes permettent de la reconnaître sans ajouter immédiatement une interface.

Dans son graphe, ajoutez On Component Begin Overlap. Reprenez le cast vers BP_PersonnageCour et la comparaison entre Other Comp et sa capsule.

La sortie validée appellera une fonction du personnage, que nous allons créer. La zone détecte ainsi l’entrée ; le personnage conserve la règle qui détermine si l’objectif peut être validé.

Vérifier la condition de réussite

Dans BP_PersonnageCour, créez TenterValiderObjectif. Commencez par un Branch utilisant ObjectifValide.

Si cette valeur est True, laissez la sortie sans action. Si elle est False, poursuivez vers un second Branch.

Pour sa condition, comparez NombreObjetsCollectes à NombreObjetsRequis avec une comparaison entière « supérieur ou égal ».

Sur True, placez Set ObjectifValide avec la valeur True, puis un Print String indiquant « Objectif réussi ». Sur False, affichez « Collecte incomplète : récupérez les objets avant de revenir ».

Compilez et enregistrez. Dans BP_ZoneArrivee, appelez TenterValiderObjectif sur la référence du personnage après le filtrage de sa capsule.

Le guide Flow Control explique le fonctionnement de Branch. Ici, chaque branche exprime une règle : éviter une seconde validation, puis vérifier la progression.

Prévoir le cas où le joueur arrive trop tôt

Lancez Play et entrez dans l’arrivée avant de collecter les trois objets. Le message de collecte incomplète doit apparaître, sans passer ObjectifValide à True.

Sortez de la zone, ramassez les objets, puis entrez de nouveau. Cette seconde entrée doit permettre la réussite.

Notre vérification est déclenchée par Begin Overlap. Elle ne se répète pas automatiquement pendant que le joueur reste dans la boîte. Si la progression change alors qu’il est déjà dedans, il doit sortir puis revenir avec cette configuration.

Placez donc les objets hors de l’arrivée pour rendre le parcours cohérent. Une autre conception pourrait vérifier la présence à chaque collecte, mais ce serait une logique supplémentaire.

Ce cas illustre une distinction utile : une condition peut devenir vraie sans qu’un nouvel événement appelle immédiatement la fonction qui la vérifie.

Rendre la progression compréhensible pendant les essais

Le joueur doit pouvoir associer son action à son résultat. Dans ce prototype, la disparition d’un objet et l’affichage du compteur fournissent deux indications complémentaires.

La référence Print String présente un outil d’affichage et de journalisation destiné au développement. Utilisez-le pour contrôler les états pendant les essais, sans le considérer comme un affichage final garanti dans une version distribuée.

Une interface dédiée pourra ensuite présenter un compteur permanent et un écran de réussite. Pour l’instant, vérifiez la règle avant de travailler cette présentation.

Cette séparation aide à analyser les mécaniques Gaming : la progression interne, le retour visible et la compréhension du joueur doivent rester cohérents. Une collecte correctement comptée mais mal signalée peut sembler ne pas avoir fonctionné.

Tester les situations qui peuvent casser la boucle

Effectuez plusieurs essais courts en repartant du début :

1. Entrer dans l’arrivée avec zéro objet.
2. Ramasser un objet et repasser à son emplacement.
3. Collecter les trois objets dans un ordre différent.
4. Rejoindre l’arrivée après la collecte complète.
5. Sortir puis rentrer après la réussite.

Le compteur doit augmenter une fois par objet. L’arrivée doit refuser une progression insuffisante et ne pas annoncer une nouvelle réussite après validation.

Si le total ne change pas, contrôlez l’événement, le cast, la comparaison de capsule et la cible d’AjouterObjet. Si un objet disparaît sans progression, examinez l’ordre des connexions.

Si l’arrivée accepte trop tôt, vérifiez la comparaison et les valeurs du personnage. Une variable correctement nommée peut malgré tout contenir une mauvaise valeur par défaut.

Comprendre ce qui revient à zéro entre les sessions

Lorsque vous arrêtez Play puis démarrez une nouvelle session, notre prototype retrouve les objets du niveau et les valeurs initiales du personnage. Cette remise à zéro permet de répéter les essais.

Enregistrer les Blueprints et le niveau conserve votre travail de création. Cela ne sauvegarde pas automatiquement le nombre d’objets ramassés pendant la partie.

Une progression persistante demande une logique dédiée. Unreal Engine propose notamment des classes SaveGame pour conserver les données nécessaires entre les sessions, comme l’explique son guide de sauvegarde et de chargement.

Pour cet exercice, gardez le redémarrage complet. Un système de respawn, de changement de niveau ou de sauvegarde obligerait à préciser davantage où vivent les données et comment elles sont restaurées.

Stabiliser la mécanique avant d’ajouter de nouvelles règles

Vous disposez maintenant d’une boucle complète : collecter, suivre la progression et valider un objectif. Sa petite taille permet de comprendre chaque référence et chaque condition.

Gardez les graphes organisés, avec des noms explicites et des commentaires décrivant les étapes. Les événements suffisent à cette mécanique ; il n’est pas nécessaire de vérifier le compteur à chaque image avec Event Tick.

Enregistrez toutes les ressources modifiées, puis rouvrez le projet pour refaire le parcours. Vérifiez aussi qu’il contient exactement trois objets accessibles et une arrivée identifiable.

Avant d’ajouter un chronomètre, un danger ou un inventaire, assurez-vous que cette boucle fonctionne régulièrement. La prochaine mécanique sera plus facile à construire si la collecte et la réussite constituent déjà une base fiable.

Les images utilisées pour illustrer cet article ont été créées à l’aide de l’intelligence artificielle.

QUESTIONS FRÉQUENTES

• Quelle première mécanique construire dans Unreal Engine 5 ?
  Une collecte avec un compteur et une arrivée conditionnelle permet de créer une petite boucle de gameplay compréhensible.
• Où conserver le compteur dans ce prototype ?
  Dans BP_PersonnageCour. Il appartient à cette instance et n’est pas automatiquement conservé si le personnage est recréé.
• Comment empêcher qu’un objet soit compté plusieurs fois ?
  Filtrez la détection sur la capsule, vérifiez DejaCollecte et passez cette variable à True avant d’ajouter la collecte.
• À quoi sert le cast vers BP_PersonnageCour ?
  Il vérifie la compatibilité de l’acteur détecté et permet d’appeler les fonctions prévues dans cette classe.
• Quand faut-il utiliser Destroy Actor ?
  Après avoir mis à jour la progression, en ciblant l’objet collectable lui-même pour le retirer de la session.
• Comment valider l’objectif à l’arrivée ?
  Comparez le total collecté au nombre requis, puis mémorisez la réussite pour éviter une seconde validation.
• Pourquoi faut-il parfois sortir puis revenir dans l’arrivée ?
  La vérification se produit à l’entrée. Elle n’est pas relancée automatiquement pendant que le personnage reste dans la boîte.
• Enregistrer le projet conserve-t-il la progression de la partie ?
  Non. L’enregistrement conserve la création ; une progression persistante demande un système de sauvegarde dédié.

Vous avez apprécié cet article ? Partagez-le !
N’hésitez pas à livrer votre avis ou vos impressions en commentaire !
Sur nos articles, l’information est accessible à 100% gratuitement
Suivez-nous sur nos réseaux sociaux : Facebook et Instagram
Rejoignez également le serveur Discord d’Info Gaming : Discord

D’AUTRES INFOS GAMING

• 
  Gaming > Nouveauté > Mystical II : Les savoirs oubliés arrive sur Steam le 3 décembre
  Acheter les bons objets, reconnaître les familles et garder suffisamment de place pour poursuivre ses recherches : Mystical II : Les savoirs oubliés propose une aventure de réflexion dans un univers médiéval.
• 
  Gaming > Nouveauté > Disbond
  Disbond prépare une chasse aux survivants dans laquelle les ennemis étaient, quelques instants plus tôt, des coéquipiers. Développé et édité par Bozz Studio, ce jeu de tir multijoueur à la première personne oppose humains et zombies sur PC Windows.
• 
  Gaming > Guide > Créer les premières mécaniques de gameplay dans Unreal Engine 5
  Créer une mécanique de gameplay consiste à relier une action du joueur, une règle et une conséquence observable. Dans Unreal Engine 5, les Blueprints permettent de construire ces relations visuellement.
• 
  Gaming > Nouveauté > Ghost in the SQL Data
  Un appel signale l’incendie d’une école quatorze minutes avant que le premier témoin aperçoive les flammes. Qui a téléphoné aussi tôt ? Dans Ghost in the SQL Data, la réponse se cherche au milieu d’une année d’appels aux services d’urgence parisiens.
• 
  Gaming > Guide > Programmer sans coder grâce aux Blueprints dans Unreal Engine 5
  Les Blueprints permettent de programmer des comportements dans Unreal Engine 5 en reliant des nœuds visuels. Ils évitent de commencer par écrire du code C++, mais reposent toujours sur une logique de programmation : recevoir un événement, vérifier une condition et déclencher une action.
• 
  Gaming > Guide > Ajouter un personnage et gérer ses déplacements dans Unreal Engine 5
  Ajouter un personnage jouable dans Unreal Engine 5 demande de relier plusieurs éléments : un modèle visible, un système de déplacement, des commandes et une caméra. Pour un débutant, le modèle Third Person fournit déjà cette base.