Projet 6 - Initiation à l'engin de jeu

Interactions simples

Cet atelier vous familiarisera avec les Blueprints d'Actor et l'utilisation des Timelines pour créer des mouvements et des interactions fluides. Ajoutez des mécaniques simples (Ramasser un objet, déclancer un dialogue ou un effet sonore) à votre jeu !

✅ Remise

📁 Livrable final

1 - Chambre secrète

Lien du dossier OneDrive comprenant :

  • Package

  • Vidéo du gameplay (MP4)

Remise et avis

Auto-évaluation

🧭 Objectifs

À la fin de cet atelier, tu auras développé ces compétences :

  • Compréhension de la programmation visuelle : Vous saurez ce qu'est un langage de programmation basé sur des nœuds et comment il fonctionne, ce qui vous donnera une base solide pour d'autres outils similaires.

  • Maîtrise des concepts de base de la programmation : Vous apprendrez à utiliser des événements déclencheurs, qui sont des concepts fondamentaux en programmation pour contrôler le flux d'exécution d'un programme.

  • Débogage simple : En utilisant la fonction Print String, vous saurez comment vérifier si une action se déclenche correctement, une compétence essentielle pour résoudre des problèmes dans n'importe quel code.

  • Familiarité avec l'interface d'Unreal Engine 5 : Vous serez à l'aise pour naviguer dans l'éditeur de Blueprint et ses différentes zones, ce qui est un premier pas important pour développer sur ce moteur de jeu.

  • Création de votre premier programme : Vous serez capable de créer une interaction simple (afficher du texte à l'écran) de manière autonome, ce qui est une étape cruciale pour commencer à construire des fonctionnalités plus complexes.



🏗️ L'atelier

Exercices

Exercice 1 : La Porte Coulissante (BP_Door)

L'objectif est de faire coulisser une porte lorsqu'un joueur s'approche.

Étape

Tâche

Nœuds Clés

A. Mise en place

Créez un Blueprint Class (Actor) nommé BP_SlidingDoor. Ajoutez un Static Mesh Component (ex: un mur) pour représenter la porte.

Static Mesh, Blueprint Class

B. Déclencheur

Ajoutez une Box Collision Component autour de la porte. Créez un événement On Component Begin Overlap pour cette Box Collision.

Box Collision, Event Begin Overlap

C. Le Mouvement

Dans le Graph : ajoutez un nœud Timeline.

Timeline

D. Courbe de Mouvement

Double-cliquez sur la Timeline. Créez une nouvelle piste Float : Départ (0.0 sec, Valeur 0.0) et Fin (1.0 sec, Valeur 1.0).

Float Track

E. Connexion

Connectez la broche Update de la Timeline à un nœud Set Relative Location du Mesh de la porte.

Update, Set Relative Location

F. Interpolation

Utilisez un nœud Lerp (Vector) : A (position Fermée), B (position Ouverte, ex: Z + 300). Branchez la valeur de la Timeline à l'entrée Alpha du Lerp.

Lerp (Vector), Get Relative Location

G. Logique Finale

Sur l'événement On Component End Overlap, appelez la fonction Reverse sur la Timeline pour que la porte se referme.

Event End Overlap, Reverse


Exercice 2 : L'Ascenseur à Bouton (BP_Lift & BP_Button)

L'objectif est d'utiliser un Actor séparé (un bouton) pour contrôler le mouvement de l'ascenseur.

Étape

Tâche

Nœuds Clés

A. L'Ascenseur

Créez un BP Class (Actor) nommé BP_Lift. Ajoutez un Static Mesh (la plateforme). Créez une Timeline similaire à la porte (durée 2.0 sec) pour contrôler le mouvement vertical (ex: Z + 500).

BP_Lift, Timeline

B. Le Bouton

Créez un BP Class (Actor) nommé BP_Button. Ajoutez un Static Mesh pour le bouton et une Box Collision plus petite.

BP_Button

C. Référence

Dans BP_Button, ajoutez une variable de type BP_Lift et cochez Instance Editable (l'œil) pour pouvoir pointer vers l'ascenseur dans le niveau.

Variable (BP_Lift Ref), Instance Editable

D. Commande

Sur l'événement On Component Begin Overlap du bouton, utilisez la variable BP_Lift pour appeler la fonction Play de la Timeline de l'ascenseur.

Cast To BP_Lift, Play

E. Exercice Supplémentaire

Dans le niveau, placez l'ascenseur, puis placez le bouton et cliquez sur le bouton pour sélectionner l'ascenseur dans le panneau Details (grâce à l'option Instance Editable).

(Vérification dans le niveau)


Exercice 3 : Le Coffre à Ouvrir (BP_Chest)

L'objectif est de créer une interaction simple (ouvrir le couvercle) et une récompense de jeu simple.

Étape

Tâche

Nœuds Clés

A. Le Coffre

Créez un BP Class (Actor) nommé BP_Chest. Ajoutez deux Static Mesh Components (le corps du coffre et le couvercle).

Static Mesh (Lid)

B. L'Ouverture

Créez une Timeline pour faire pivoter le couvercle. Utilisez le nœud Set Relative Rotation sur le Mesh du couvercle. (Ex: Rotation sur l'axe X de 0 à 90 degrés).

Timeline, Set Relative Rotation

C. Le Ramassage

Sur l'événement clavier E : utilisez un Sphere Trace (comme dans le tutoriel d'inventaire) ou un Overlap simple pour vous assurer que le joueur est proche.

Input E, Sphere Trace

D. Logique

Si le joueur est proche : 1. Appelez Play sur la Timeline d'ouverture. 2. Affichez un message Print String : "Vous avez trouvé 1 Pièce d'Or !".

Play, Print String

E. Défi (Prévention)

Ajoutez un Booléen nommé IsOpened. Vérifiez si le coffre est déjà ouvert avant de lancer l'ouverture. Si IsOpened est vrai, n'affichez rien. Mettez IsOpened à vrai après l'ouverture.

Variable Booléenne, Branch


Livrable final

Livrable 1 : Chambre secrète

Une fois que tous les éléments fonctionnent séparément :

  1. Construisez une petite "Chambre Secrète" dans votre niveau.

  2. Placez la BP_SlidingDoor en entrée.

  3. Placez l'BP_Lift qui mène à un niveau supérieur.

  4. Placez le BP_Button pour activer l'ascenseur.

  5. Placez le BP_Chest comme trésor final.

Vous pouvez télécharger un modèle de coffre ici: treasure-chest.zip

Objectif final : Le joueur doit traverser la porte, utiliser le bouton pour monter l'ascenseur, et ouvrir le coffre pour gagner.
Package ton jeu et l'exporter.

Le deadline du projet est vendredi de la semaine 16 à 11h59.

🎓 La théorie

Qu’est-ce qu’un Blueprint ?

Le Blueprint est un langage de programmation visuelle développé par Epic Games. Il vous permet de créer des fonctionnalités et des comportements dans un jeu vidéo sans avoir à écrire de code complexe comme en C++.

Son fonctionnement est basé sur des nœuds (ou nodes en anglais) qui représentent des actions ou des éléments du jeu. Ces nœuds sont reliés entre eux par des traits pour former des séquences d'instructions. Cela rend la logique de programmation facile à comprendre et à modifier, même pour les artistes et les concepteurs de jeux.

En résumé :

  • Les boîtes = des actions ou des valeurs

  • Les fils blancs = l’ordre d’exécution

    Les fils colorés = le passage de données (valeurs, positions, booléens…)


Les types de Blueprints

Il existe deux types de Blueprints principaux :

  • Level Blueprint : Chaque niveau (ou "map") a son propre Level Blueprint. Il est utilisé pour manipuler des acteurs, contrôler des cinématiques, ou créer des points de contrôle spécifiques à ce niveau.

  • Blueprint Class : Ces classes sont conçues pour créer des objets interactifs réutilisables, comme des portes qui s'ouvrent, des leviers ou des plateformes mouvantes

Il en existe plusieurs de BP class, mais les 3 plus utilisés pour commencer sont :

Type

Utilité

Exemple

Actor Blueprint

Objet placé dans le monde

Porte, coffre, lampe

Character Blueprint

Personnage jouable ou ennemi

Joueur, bot

Widget Blueprint

Interface utilisateur

Inventaire, barre de vie

Créer son premier Blueprint

Dans Content Browser → clic droit → Blueprint Class

  1. Choisis Actor

  2. Nomme-le par ex. BP_Lampe

  3. Double-clique pour l’ouvrir


Interface d’un Blueprint

Quand tu ouvres ton Blueprint, tu as 3 onglets principaux :

  1. Viewport → pour placer des objets visuels (ex. mesh, lumières)

  2. Construction Script → pour configurer automatiquement des choses quand l’objet est créé

  3. Event Graph → le cœur de la logique (les nœuds de code visuel)

Les événements de base

Quand tu ouvres l’Event Graph, tu vois souvent :

  • Event BeginPlay → se déclenche quand l’objet apparaît dans le jeu


  • Event Tick → se déclenche à chaque frame (60 fois/s en moyenne)


  • Event OnActorBeginOverlap → quand quelque chose entre en collision avec l’objet


Créer votre premier code

Pour créer une action, vous avez besoin d'un événement déclencheur qui va lancer la séquence d'instructions. Voici comment créer un programme qui affiche "Hello World" lorsque vous lancez le jeu.

  1. Ajouter l'événement Event Begin Play :

    • Faites un clic droit dans l'Event Graph.

    • Dans la barre de recherche, tapez Event Begin Play.

    • Sélectionnez le nœud pour l'ajouter à votre zone de travail.

  2. Cet événement se déclenche une seule fois, au début du jeu, lorsque vous entrez dans le niveau.


  3. Ajouter la fonction Print String :

    • Cliquez sur le petit triangle du nœud Event Begin Play et, tout en maintenant le clic gauche, faites glisser la souris pour tirer une ligne. Relâchez le clic.

    • Dans le menu qui apparaît, recherchez la fonction Print String.

    • Sélectionnez-la pour l'ajouter et la connecter à votre nœud Event Begin Play.


  4. Le nœud Print String est très utile pour le débogage. Il permet d'afficher du texte à l'écran ou dans la console.


  5. Modifier le texte et tester :

    • Dans le nœud Print String, double-cliquez sur le champ de texte pour le modifier. Entrez "Hello World".

    • Dans la Toolbar, cliquez sur Compile, puis sur Save.

    • Revenez dans votre niveau et cliquez sur le bouton Play. Vous devriez voir "Hello World" s'afficher en haut à gauche de l'écran.


Bonus : Un autre événement déclencheur

L'événement Event Tick est un autre déclencheur très courant. Il s'active à chaque image du jeu (chaque "frame").

Pour l'utiliser, il suffit de le connecter à votre nœud Print String à la place de Event Begin Play. Vous pouvez retirer la connexion entre les nœuds en maintenant la touche Alt et en faisant un clic gauche sur le nœud.

  • Connectez Event Tick au nœud Print String.

  • Cliquez sur Compile et Save.

  • Lancez le jeu.



Vous remarquerez que "Hello World" s'affiche de manière continue et très rapide, car il est exécuté à chaque image. C'est un événement très puissant, mais il peut avoir un impact sur les performances du jeu s'il est utilisé de manière incorrecte.

Exemple simple : Faire allumer une lampe

On va créer une lampe qui s’allume quand on s’en approche.

Étapes :

  1. Dans le Viewport → ajoute un Static Mesh (ex. lampadaire) + un Point Light


  2. Dans Event Graph :

    • Event Tick (inutile ici)

    • Click droit → → Get Player Controller from Input Device

    • Click droit → → Was Input Key Pressed si vous ne le trouvez pas, décochez Context Sensisive, Key choisissez votre bouton sur le clavier.

    • Connect Return Value to Target

    • Ajoutons une condition pour ouvrir et fermer la lumière : Click droit → → Branch → → Click droit → → Toggle Visibility (Point Light)

    • Si c'est vrai (allumé)True de Branch à Toggle Visibility

    • Si c'est faux (éteint): Return Value du bouton à la Condition de Branch



Pseudo-Blueprint :

Event BeginPlay → PointLight → Set Visibility (False)

OnActorBeginOverlap → PointLight → Set Visibility (True)

OnActorEndOverlap → PointLight → Set Visibility (False)


Félicitations, vous venez de créer votre première ligne de code visuelle en Blueprint !Maintenant, on va découvrire les variables.

Les variables

Les variables, un concept essentiel en programmation et sur le système de programmation visuelle Blueprint.. En Blueprint sous Unreal Engine 5, les variables sont comme des boîtes où l’on range des informations pour s’en servir plus tard.
Elles permettent de stocker et manipuler des données qui peuvent changer pendant le jeu.

Les variables sont des éléments de programmation utilisés dans les jeux vidéo pour stocker et manipuler des données dynamiques. Elles permettent de garder une trace de l'état du jeu et de contrôler son comportement. Par exemple, elles peuvent suivre le temps écoulé, le nombre de tours complétés ou le score d'un joueur. Elles peuvent également stocker des informations sur les personnages (santé, niveau de compétence) ou l'environnement (météo


Les variables permettent de stocker des infos :

  • Bool → vrai/faux (lampe allumée ou non)

  • Integer → nombre entier (3, 45)

  • Float → nombre à virgule (5.48, 1.25)

  • Vector → position dans l’espace (X, Y, Z)

  • String → texte

💡 Astuce : Tu peux cocher Instance Editable pour modifier la valeur directement dans l’éditeur.

Exemples dans un jeu :

  • Score du joueur.

  • Santé d’un personnage.

  • Nom choisi par le joueur.

  • État d’un interrupteur (allumé / éteint).

Logique et conditions

Tu peux créer des conditions avec des nœuds comme :

  • Branch → si / sinon

  • Equal, Greater, Less → comparaisons


Exemple :

Si joueur a clé → ouvre la porte

Sinon → affiche "Il vous manque la clé"



Bonnes pratiques

  • Nommer tes nœuds clairement

  • Commenter tes groupes de nœuds (C pour ajouter un cadre de commentaire)

  • Éviter les Tick inutiles (gourmand en performances)

  • Tester souvent en appuyant sur Play


Prochaines étapes

  • Faire un coffre qui donne un objet

  • Créer un bouton qui déclenche un mécanisme

  • Commencer un inventaire simple avec un Widget Blueprint

Création d'une IA Ennemie de Base dans Unreal Engine 5

Module 1 : Mise en place du Character (L'Enveloppe)

La première étape consiste à créer l'objet qui servira d'ennemi dans le jeu.

  1. Création du Blueprint :

    • Allez dans votre dossier de contenu (Content Browser).

    • Faites un clic droit > Blueprint Class.

    • Choisissez Character (car nous voulons qu'il puisse marcher et utiliser un système de mouvement).

    • Nommez-le BP_EnemyAI.

  2. Configuration du Mesh :

    • Ouvrez BP_EnemyAI.

    • Sélectionnez le composant Mesh dans la liste à gauche.

    • Dans le panneau Details, choisissez un Skeletal Mesh (par exemple le Mannequin ou "The Queen" comme dans la vidéo).

    • Ajustements :

      • Position Z : environ -85 ou -90 (pour que les pieds touchent le sol).

      • Rotation Z : -90 degrés (pour qu'il regarde vers la flèche bleue "Forward").

    • Compilez et Sauvegardez.


Le Système de Vision (Sensing)

L'ennemi a besoin "d'yeux" pour repérer le joueur.

  1. Ajouter le composant :

    • Dans BP_EnemyAI, cliquez sur Add et cherchez PawnSensing.

    • Ce composant gère la vue et l'ouïe.

  2. Paramétrage :

    • Dans les Details du PawnSensing :

      • Peripheral Vision Angle : Réduisez-le à environ 70 (pour un champ de vision plus réaliste).

      • Sight Radius : Définit la distance de vue (laisser par défaut ou ajuster selon besoin).

  3. Logique de détection (Event Graph) :

    • Sélectionnez le PawnSensing.

    • Dans la section Events (en bas à droite), cliquez sur On See Pawn.

    • Créez une variable booléenne nommée IsSeeingPlayer.

Lorsque l'événement se déclenche, mettez cette variable à True.

Navigation et Mouvements

Pour que l'IA puisse bouger, elle doit savoir où elle a le droit de marcher.

  1. Le NavMesh (Dans le niveau) :

    • Dans l'éditeur principal, allez dans le panneau Place Actors.

    • Cherchez et glissez un NavMeshBoundsVolume dans votre niveau.

    • Agrandissez-le (Scale) pour qu'il englobe toute la zone où l'ennemi doit marcher.

Astuce : Appuyez sur la touche P de votre clavier. La zone verte indique où l'IA peut se déplacer.

  1. Logique de poursuite (Dans le Blueprint) :

    • Créez un Custom Event nommé FollowPlayer.

    • Ajoutez un nœud (node) Branch : Si IsSeeingPlayer est True -> continuez.

    • Ajoutez le nœud AI Move To.

      • Pawn : Self (l'ennemi lui-même).

      • Target Actor : Get Player Character (pour qu'il suive toujours le joueur).


Note : Le nœud "AI Move To" gère le déplacement automatiquement.

Les Animations (Blend Space & AnimBP)

L'ennemi glisse sur le sol. Nous devons lui donner des animations qui s'adaptent à sa vitesse.

  1. Blend Space 1D (Mélange d'animations) :

    • Dans le dossier Content, clic droit > Animation > Blend Space 1D.

    • Sélectionnez le squelette de votre ennemi. Nommez-le BS_EnemyWalk.

    • Ouvrez-le :

      • Dans Axis Settings (gauche), nommez l'axe Speed et mettez la valeur max à 600 (vitesse par défaut du character).

      • Glissez l'animation Idle à la position 0.

      • Glissez l'animation Walk vers le milieu.

      • Glissez l'animation Run à la position 600.

    • En bougeant la souris avec CTRL enfoncé, vous verrez la transition fluide.

Note : Dans unreal il existe déjà un BlendSpace Avec le Idle-Walk-Run cycle… Pour le votre choisissez le Idle.WalkFoward.JogFoward.

  1. Animation Blueprint (Le cerveau des animations) :

    • Clic droit > Animation > Animation Blueprint.

    • Nommez-le ABP_EnemyAI.

    • Anim Graph :

      • Ajoutez le nœud de votre Blend Space (BS_EnemyWalk).

      • Connectez-le au nœud de sortie (Output Pose).

      • Faites un clic droit sur l'entrée "Speed" du Blend Space > Promote to Variable.

    • Event Graph :

      • Utilisez Try Get Pawn Owner -> Cast to BP_EnemyAI.

      • Du nœud "As BP Enemy AI", tirez le fil et cherchez Get Character Movement.

      • Depuis Character Movement, cherchez Get Velocity.

      • Tirez depuis Velocity et cherchez Vector Length (pour convertir le vecteur en une valeur float : la vitesse).

      • Connectez cette valeur à votre variable Speed (Set Speed).

  2. Lier le tout :

    • Retournez dans BP_EnemyAI.

    • Sélectionnez le Mesh.

    • Dans Animation Class, sélectionnez votre ABP_EnemyAI.

Module 5 : Système de Combat (Attaque)

L'IA doit attaquer lorsqu'elle est assez proche.

  1. Préparation de l'Animation :

    • Il vous faut une Animation Montage pour l'attaque (Clic droit sur une animation d'attaque > Create Anim Montage).

    • Important : Dans l'Animation Blueprint (ABP_EnemyAI), allez dans l'Anim Graph et ajoutez un nœud Slot 'Default Slot' entre votre Blend Space et l'Output Pose. Sinon, l'attaque ne se jouera pas.

  2. Logique d'Attaque (Dans BP_EnemyAI) :

    • Allez sur votre nœud AI Move To. Il possède une sortie nommée On Success (déclenché quand l'IA a atteint la cible).

    • Créez une variable booléenne CanAttack (par défaut cochée à True).

    • Séquence logique sur "On Success" :

      1. Branch : Vérifiez si CanAttack est True.

      2. Si Oui : Set CanAttack à False (pour éviter le spam d'attaques).

      3. Play Anim Montage : Sélectionnez votre montage d'attaque.

      4. Delay : Mettez la durée de votre animation d'attaque.

      5. Set CanAttack à True (l'ennemi est prêt à attaquer de nouveau).

Finitions et Perte de Vue

Pour éviter que l'IA ne continue de courir si le joueur disparaît ou se cache.

  1. Arrêt du mouvement :

    • Dans l'événement Tick (ou via une vérification régulière), si IsSeeingPlayer devient False :

    • Appelez le nœud Stop Movement Immediately (depuis le Character Movement).

  2. Mise à jour de la vision :

    • Le composant PawnSensing a seulement un événement "On See". Pour gérer la perte de vue, il faut souvent ajouter une logique de délai ou vérifier périodiquement si le joueur est toujours dans le cône de vision (ceci est une étape avancée, mais le script de base suggère simplement d'arrêter le mouvement si la condition de vue n'est plus remplie).

Résumé des interactions

  • PawnSensing voit le joueur -> Active le booléen.

  • AI Move To déplace l'ennemi vers le joueur tant qu'il le voit.

  • AnimBP lit la vitesse de l'ennemi pour jouer l'animation (Marche/Course).

  • On Success (l'ennemi est arrivé) -> Déclenche l'attaque et gère le délai entre les coups.

Système de Santé, Dégâts et Interface (HUD) dans Unreal Engine 5

Objectif: Créer un système complet où le joueur possède une barre de vie, peut recevoir des dégâts d'une source externe, mourir, et voir sa santé affichée en temps réel sur l'écran.

Créer une Source de Dégâts (Le Piège)

Nous allons commencer par créer un objet simple qui infligera des dégâts lorsque le joueur le touchera.

  1. Création de l'Actor :

    • Dans le Content Browser, faites un clic droit > Blueprint Class > Actor.

    • Nommez-le BP_Damager.

  2. Ajout de la Collision :

    • Ouvrez le Blueprint. Cliquez sur + Add et cherchez Box Collision.

    • Dans le panneau Details, décochez Hidden in Game (pour voir la boîte pendant le test).

  3. Logique de Dégâts (Event Graph) :

    • Sélectionnez la Box Collision. Faites un clic droit > Add Event > On Component Begin Overlap.

    • À partir de la pin Other Actor, tirez un lien et cherchez le nœud Apply Damage.

    • Dans Base Damage, entrez la valeur (ex: 25).

    • Compilez, sauvegardez et placez cet actor dans votre niveau.

Module 2 : Gestion de la Santé du Joueur

Maintenant, nous allons programmer le personnage pour qu'il reçoive ces dégâts et mette à jour sa santé.

  1. Création des Variables :

    • Ouvrez le Blueprint de votre personnage (BP_ThirdPersonCharacter par exemple).

    • Créez deux variables de type Float :

      • CurrentHealth (Santé actuelle)

      • MaxHealth (Santé maximale)

    • Compilez et définissez leurs valeurs par défaut (ex: 100 pour les deux).

  2. Recevoir les Dégâts :

    • Dans l'Event Graph, faites un clic droit et ajoutez l'événement Event Any Damage.

    • Calcul : Prenez CurrentHealth, soustrayez les dégâts reçus (Damage).

    • Sécurisation (Clamp) : Ajoutez un nœud Clamp (Float) après la soustraction.

      • Min : 0

      • Max : MaxHealth (Cela empêche la vie de descendre sous 0 ou de dépasser 100).

    • Mettez à jour CurrentHealth avec ce nouveau résultat (Set CurrentHealth).

Module 3 : Gestion de la Mort

Que se passe-t-il quand la santé atteint 0 ?

  1. Vérification :

    • Après avoir mis à jour la santé, vérifiez si CurrentHealth est égal à 0 (nœud Equal).

    • Ajoutez un Branch (If).

  2. État de Mort :

    • Créez une variable booléenne IsDead.

    • Si le Branch est Vrai (Santé = 0), mettez IsDead à True.

  3. Conséquences :

    • Animation : Utilisez le nœud Play Animation (sur le Mesh) et choisissez une animation de mort.

    • Contrôles : Utilisez le nœud Disable Input. Reliez un nœud Get Player Controller à l'entrée Player Controller.

    • Immunité : Au tout début de votre logique de dégâts (avant la soustraction), ajoutez un Branch qui vérifie si IsDead est Faux. Si le joueur est déjà mort, il ne doit plus recevoir de dégâts.

L'Interface Utilisateur (Barre de Vie)

Nous allons créer un Widget pour afficher la santé.

  1. Communication (Event Dispatcher) :

    • Concept clé : Pour que l'interface se mette à jour proprement, le joueur doit "signaler" quand sa santé change.

    • Dans le Blueprint du Joueur, panneau My Blueprint > Event Dispatchers > +.

    • Nommez-le E_HealthUpdated.

    • Ajoutez deux paramètres (Inputs) de type Float : CurrentHealth et MaxHealth.

    • Utilisation : À la fin de votre chaîne de calcul de dégâts (Module 2), glissez cet Event Dispatcher et choisissez Call. Connectez-y vos variables de santé.

  2. Création du Widget :

    • Dans le Content Browser > Clic droit > User Interface > Widget Blueprint.

    • Nommez-le WBP_HUD.

    • Ajoutez un Canvas Panel, puis une Progress Bar.

    • Dans les Details de la barre : changez la couleur (Fill Color) en rouge.

    • Ajoutez un Text Block pour afficher les chiffres (ex: "100/100").

  3. Logique du Widget (Graph) :

    • Créez une Custom Event nommée Initialize. Ajoutez un Input de type Votre Character Blueprint (Object Reference).

    • À partir de cet input, faites un Bind Event to E_HealthUpdated.

    • Tirez le fil rouge (Event) du Bind et créez un Custom Event (nommez-le UpdateHealthUI).

    • Mise à jour de la Barre :

      • Calcul : CurrentHealth / MaxHealth (Division) pour obtenir un pourcentage entre 0 et 1.

      • Nœud : Set Percent (sur la Progress Bar).

    • Mise à jour du Texte :

      • Nœud : Format Text. Dans la case format, écrivez : {current} / {max}. Cela créera deux pins automatiquement.

Reliez les valeurs et connectez la sortie à un Set Text (sur votre Text Block).

Initialisation (Afficher le HUD)

Dernière étape : relier le tout au démarrage du jeu.

  1. Dans le Blueprint du Joueur (Event BeginPlay) :

    • Nœud Create Widget (Sélectionnez WBP_HUD).

    • Nœud Add to Viewport.

    • À partir de la valeur de retour du Widget, appelez votre fonction Initialize (créée dans le Module 4) et connectez Self à l'input.

    • Enfin, appelez manuellement l'Event Dispatcher E_HealthUpdated (Call) juste après, pour que la barre s'affiche pleine dès le début du jeu (sinon elle restera vide jusqu'au premier dégât).

Résumé du flux de données

  1. Le joueur touche le BP_Damager.

  2. Apply Damage est envoyé au joueur.

  3. Le joueur calcule CurrentHealth - Damage.

  4. Le joueur vérifie s'il est mort (IsDead).

  5. Le joueur envoie le signal E_HealthUpdated avec les nouvelles valeurs.

  6. Le Widget reçoit le signal et met à jour la barre et le texte.

Création d'un Système d'Endurance et de Sprint (UE5)

Mise en place du Sprint (Mouvement & Animation)

Avant de gérer l'endurance, nous devons permettre au personnage de courir.

1.1 Configuration des Inputs (Entrées)

  1. Input Action :

    • Dans le Content Browser, allez dans votre dossier d'Inputs.

    • Clic droit > Input > Input Action. Nommez-le IA_Sprint.

    • Value Type : Digital Bool.

  2. Input Mapping Context :

    • Ouvrez votre fichier Input Mapping Context.

    • Ajoutez IA_Sprint.

    • Assignez une touche (ex: Left Shift).

1.2 Logique de Vitesse (Blueprint)

  1. Ouvrez le Blueprint de votre personnage (ex: BP_ThirdPersonCharacter).

  2. Appelez l'événement IA_Sprint.

  3. Sur "Started" (Appui) :

    • Prenez le composant Character Movement.

    • Utilisez le nœud Set Max Walk Speed. Réglez-le à 1000.

  4. Sur "Completed" (Relâchement) :

    • Utilisez Set Max Walk Speed et remettez la valeur par défaut (ex: 500).

1.3 Ajustement des Animations

Le personnage va vite, mais l'animation doit suivre.

  1. Ouvrez votre Blend Space de mouvement (ex: BS_WalkRun).

  2. Changez la valeur Maximum Axis Value de l'axe horizontal à 1000.

  3. Déplacez le point d'animation de "Course" (Run) vers la position 1000.

  4. Assurez-vous que l'animation de "Marche" (Walk) est bien positionnée sur 500.

Logique de l'Endurance (Déplétion & Régénération)

Nous allons créer le cœur du système : les mathématiques de l'énergie.

2.1 Les Variables

Dans le Blueprint du personnage, créez les variables suivantes (Type Float) :

  • CurrentStamina (Valeur par défaut : 100).

  • MaxStamina (Valeur par défaut : 100).

  • StaminaDepletionInterval (ex: 0.1s - fréquence de perte).

  • StaminaGainInterval (ex: 0.05s - fréquence de gain).

  • DepletionTimer (Type: Timer Handle - pour gérer la boucle de perte).

  • GainTimer (Type: Timer Handle - pour gérer la boucle de gain).

2.2 Perdre de l'endurance (Sprint)

  1. Timer : Sur l'événement IA_Sprint (Started), ajoutez un nœud Set Timer by Event.

    • Cochez Looping.

    • Time : StaminaDepletionInterval.

    • Faites un clic droit sur "Return Value" > Promote to Variable (DepletionTimer).

  2. Calcul (Custom Event) : Créez un Custom Event nommé RemoveStamina et liez-le au Timer.

    • Prenez CurrentStamina - 1 (Subtract).

    • Ajoutez un Clamp (Float) (Min: 0, Max: MaxStamina).

    • Mettez à jour CurrentStamina avec ce résultat.

  3. Arrêt du Timer : Sur IA_Sprint (Completed), utilisez le nœud Clear and Invalidate Timer by Handle avec la variable DepletionTimer.

2.3 Regagner de l'endurance (Repos)

  1. Timer : Sur IA_Sprint (Completed), après avoir arrêté le sprint, ajoutez un autre Set Timer by Event.

    • Time : StaminaGainInterval (plus rapide pour recharger vite).

    • Promote to Variable (GainTimer).

  2. Calcul (Custom Event) : Créez un événement AddStamina.

    • Prenez CurrentStamina + 1 (Add).

    • Ajoutez un Clamp (Min: 0, Max: MaxStamina).

    • Mettez à jour CurrentStamina.

  3. Conflit : Pensez à ajouter un Clear Timer pour GainTimer au moment où vous commencez à sprinter (Started), pour ne pas gagner et perdre de l'énergie en même temps.

Restrictions et Forçage

Que se passe-t-il si l'endurance tombe à 0 ?

3.1 Arrêt forcé

  1. Dans la logique RemoveStamina, après le calcul :

  2. Vérifiez si CurrentStamina <= 0.

  3. Si Vrai (Branch) : Appelez un nouvel événement personnalisé StopSprinting.

  4. L'événement StopSprinting doit faire la même chose que lorsque le joueur relâche la touche (Remettre la vitesse à 500, couper le timer de déplétion, lancer le timer de gain).

3.2 Arrêt de la régénération

  1. Dans la logique AddStamina, après le calcul :

  2. Vérifiez si CurrentStamina >= MaxStamina.

  3. Si Vrai : Utilisez Clear and Invalidate Timer by Handle sur GainTimer pour arrêter le calcul inutile une fois la barre pleine.

Interface Utilisateur (Barre d'Endurance)

Affichons ces données à l'écran.

4.1 Le Widget (HUD)

  1. Créez un Widget Blueprint (WBP_Stamina).

  2. Ajoutez une Progress Bar.

    • Nommez-la ProgressBar_Stamina.

    • Cochez Is Variable.

    • Changez la couleur (Fill Color) en vert ou jaune.

4.2 Communication (Event Dispatcher)

Pour optimiser, nous n'utiliserons pas de "Cast" à chaque frame, mais un dispatcher.

  1. Dans le Character Blueprint :

    • Créez un Event Dispatcher nommé E_UpdateStamina.

    • Ajoutez deux Inputs Float : Current et Max.

    • Appelez ce Dispatcher (Call) à la fin des événements RemoveStamina et AddStamina.

  2. Dans le Widget Blueprint :

    • Créez un événement d'initialisation qui reçoit le "Player Character".

    • Faites un Bind Event to E_UpdateStamina.

    • Depuis l'événement rouge (Event), créez un Custom Event UpdateBar.

    • Mathématiques : Current / Max = Pourcentage.

    • Envoyez ce résultat dans le nœud Set Percent de la barre de progression.

4.3 Affichage au démarrage

  1. Dans le BeginPlay du personnage :

    • Create Widget (WBP_Stamina).

    • Add to Viewport.

    • Initialisez le Widget en envoyant Self (le personnage).

Résumé des Interactions

  1. Touche Shift enfoncée —> Vitesse 1000 —> Timer Déplétion ON —> Timer Gain OFF.

  2. Touche relâchée —> Vitesse 500 —> Timer Déplétion OFF —> Timer Gain ON.

  3. Endurance = 0 —> Force l'état "Touche relâchée".

  4. Endurance modifiée -> Envoi du signal au Widget -> La barre se met à jour visuellement.

Création d'un système de combat de base dans UE5

Gestion des animations

Avant de coder, il faut préparer les animations. Le tutoriel utilise un pack d'animations gratuit (type Paragon), mais la méthode s'applique à tout asset.

1.1 Importation et Retargeting

Si vos animations sont sur l'ancien squelette (UE4 Mannequin) et que vous utilisez le nouveau (UE5 Manny/Quinn), vous devez les convertir.

  1. Importer : Glissez vos animations dans le Content Browser. Sélectionnez le squelette SK_Mannequin (l'ancien) lors de l'import.

  2. Retargeting :

    • Faites un clic droit sur l'animation d'attaque.

    • Allez dans Retarget Animation Assets > Duplicate and Retarget Animation Assets.

    • Dans le "Retargeter", sélectionnez RTG_Mannequin (ou celui qui convertit UE4 vers UE5).

    • Cliquez sur Retarget. Vous avez maintenant une animation compatible avec votre personnage UE5.

1.2 Création de l'Animation Montage

Le "Montage" permet de jouer une animation spécifique par-dessus les mouvements de base (marche/course) via le Blueprint.

  1. Faites un clic droit sur votre nouvelle animation d'attaque > Create > Create Anim Montage.

  2. Édition (Optionnel) : Si l'animation est trop longue (ex: le personnage frappe puis se fait toucher), ouvrez le Montage.

    • Mettez la lecture en pause à l'endroit où vous voulez couper.

    • Faites un clic droit sur la timeline > Remove from frame [X] to [Y].

    • Cela permet de garder uniquement le coup de poing.

Logique d'attaque (Blueprint du joueur)

Nous allons maintenant déclencher cette animation.

  1. Ouvrez le Blueprint de votre personnage (ex: BP_ThirdPersonCharacter).

  2. Créer l'événement d'attaque :

    • Créez un Custom Event et nommez-le Attack.

    • Ajoutez le nœud Play Anim Montage.

    • Dans le menu déroulant du nœud, sélectionnez votre montage créé au Module 1.

  3. Lier l'Input :

    • Cherchez l'événement Left Mouse Button (ou votre input d'attaque).

    • Reliez-le à l'appel de l'événement Attack.

À ce stade, si vous lancez le jeu, le personnage joue l'animation quand vous cliquez.

Système de détection (Line Trace)

Pour savoir si on touche un ennemi, nous allons tracer une ligne invisible devant le joueur au moment de l'attaque.

3.1 Préparation des points de départ et d'arrivée

Au lieu d'utiliser des Sockets complexes pour ce tutoriel basique, nous utiliserons des composants "Arrow" (Flèches) pour définir la zone de frappe.

  1. Dans le Viewport de votre personnage, ajoutez deux composants Arrow.

  2. Nommez le premier StartAttack (placez-le près de l'épaule/torse).

  3. Nommez le second EndAttack (placez-le devant le joueur, à portée de poing).

3.2 Le Raycast (Line Trace)

Retournez dans l'Event Graph du personnage, à la suite du nœud Play Anim Montage :

  1. Ajoutez un nœud Line Trace By Channel.

  2. Calculer le Start : Prenez le composant StartAttack -> Get World Location. Reliez à la pin Start.

  3. Calculer le End : Prenez le composant EndAttack -> Get World Location. Reliez à la pin End.

  4. Debug : Changez "Draw Debug Type" sur For Duration (pour voir la ligne rouge lors du test).

  5. Gestion des dégâts :

    • À partir de la pin de sortie du Line Trace (Out Hit), ajoutez un Break Hit Result.

    • Prenez la pin Hit Actor du Break Hit Result.

    • Ajoutez le nœud Apply Damage.

    • Définissez la Base Damage (ex: 2.0).

Création de l'ennemi (Dummy)

Créons un mannequin d'entraînement qui reçoit les dégâts.

  1. Créez un nouveau Blueprint Class de type Character (Important : Character gère mieux les collisions que Pawn par défaut). Nommez-le BP_Dummy.

  2. Ajoutez un Skeletal Mesh (le mannequin par défaut).

  3. Collision : Sélectionnez la Capsule Component, cherchez "Collision" et assurez-vous qu'elle est en Block All (pour que le Line Trace puisse la toucher).

4.1 Logique de Santé

Dans l'Event Graph du BP_Dummy :

  1. Créez une variable Float nommée Health (Valeur par défaut : 10).

  2. Appelez l'événement Event Any Damage (c'est lui qui reçoit le "Apply Damage" du joueur).

  3. Calcul des dégâts :

    • Faites Health - Damage (Soustraction).

    • Mettez à jour la variable Health (Set).

  4. Vérification de la mort :

    • Ajoutez un Branch (If).

    • Condition : Si Health <= 0.

    • Si Vrai (True) : Destroy Actor.

    • (Optionnel) Ajoutez un Print String "Aie" ou "Mort" pour vérifier que ça marche.

Finitions et Cooldown (Anti-Spam)

Actuellement, si le joueur clique très vite, l'animation se relance en boucle (glitch) ou on peut attaquer 10 fois par seconde. Il faut limiter cela.

  1. Dans le BP_ThirdPersonCharacter, créez une variable Booléenne nommée CanAttack (Cochez la valeur par défaut à True).

  2. Au début de l'attaque :

    • Juste après l'Input (Clic gauche), ajoutez un Branch.

    • Condition : CanAttack.

    • Si True -> Continuez vers l'événement Attack.

  3. Dans l'événement Attack :

    • Tout au début, mettez CanAttack à False (Set).

  4. Réinitialisation :

    • Après le Play Anim Montage (et le Line Trace), ajoutez un Delay.

    • Durée du délai : Pour être précis, prenez la pin Return Value du Play Anim Montage (qui donne la durée de l'anim) et branchez-la dans la durée du Delay.

    • Après le Delay, mettez CanAttack à True.

Résumé du flux final :

  1. Le joueur clique.

  2. Le système vérifie si CanAttack est vrai.

  3. Si oui, CanAttack devient faux.

  4. L'animation se lance.

  5. Le Line Trace vérifie ce qui est devant. Si c'est un ennemi, il lui envoie "Apply Damage".

  6. L'ennemi reçoit les dégâts, réduit sa vie, et meurt si elle atteint 0.

  7. Une fois l'animation finie, CanAttack redevient vrai.

Système de combat avancé (Variations & Audio) sur Unreal Engine 5

Importation et Conversion des Animations

Nous allons ajouter de nouvelles animations (ex: Coup de pied, Coup puissant) pour varier les combos.

1.1 Importation

  1. Téléchargez vos animations (Vous pouvez utiliser les animations mixamo).

  2. Glissez-les dans votre dossier Animations.

  3. Lors de l'import, choisissez le squelette UE4 Mannequin (si vos animations proviennent d'un ancien pack).

1.2 Retargeting (Conversion UE4 vers UE5)

Pour utiliser ces animations sur le nouveau mannequin UE5 :

  1. Sélectionnez les animations importées (ex: Push, Aerial Swing).

  2. Faites un clic droit > Retarget Animation Assets > Duplicate and Retarget Animation Assets.

  3. Dans la fenêtre :

    • IK Retargeter : Sélectionnez RTG_Mannequin (ou celui qui gère UE4 vers UE5).

    • Source : UE4 / Target : UE5.

  4. Cliquez sur Retarget.

  5. Déplacez les nouvelles animations générées dans votre dossier principal pour l'organisation.

1.3 Création des Montages

Pour chaque nouvelle animation convertie :

  1. Faites un clic droit sur l'animation.

  2. Sélectionnez Create > Create Anim Montage.

  3. Vous avez maintenant vos montages prêts à être appelés en Blueprint.

Logique de Randomisation (Blueprint)

Au lieu de toujours jouer la même attaque, nous allons demander au jeu de choisir un nombre au hasard et de jouer l'animation correspondante.

2.1 Préparation du Script

Ouvrez votre BP_ThirdPersonCharacter (ou votre Character Blueprint).

  1. Créez une nouvelle fonction ou un Custom Event nommé RandomAnimation.

  2. Créez une nouvelle Variable :

    • Nom : AttackNum (Numéro d'attaque).

    • Type : Integer (Nombre entier).

2.2 Le calcul aléatoire

Dans votre événement RandomAnimation :

  1. Tirez un lien et ajoutez le nœud Set AttackNum.

  2. Pour la valeur, cherchez le nœud Random Integer in Range.

    • Min : 0

    • Max : 2 (Si vous avez 3 animations : 0, 1 et 2).

2.3 La sélection (Branches)

À la suite du Set AttackNum, nous allons vérifier quel chiffre a été tiré :

  1. Ajoutez un nœud Branch (B).

  2. Condition : AttackNum Equals (==) 0.

  3. Si True : Ajoutez le nœud Play Anim Montage et sélectionnez votre Animation 1 (ex: Punch de base).

  4. Si False : Ajoutez un autre Branch.

    • Condition : AttackNum Equals (==) 1.

    • Si True : Play Anim Montage avec Animation 2 (ex: Push).

    • Si False : Play Anim Montage avec Animation 3 (ex: Aerial Swing).

2.4 Gestion du délai (Cooldown)

Pour que le système de cooldown (créé en partie 1) fonctionne avec des animations de durées différentes :

  1. Créez une variable Float nommée DelayDuration.

  2. Après chaque nœud Play Anim Montage, ajoutez un Set DelayDuration.

  3. Reliez la sortie "Return Value" du nœud Play Anim Montage (qui donne la durée exacte de l'anim) à la valeur de DelayDuration.

  4. Note : Assurez-vous que votre logique d'attaque principale utilise cette variable pour son délai de réinitialisation.

Système audio (Sound FX)

Ajoutons de l'impact aux coups.

3.1 Son simple

  1. Importez vos sons (WAV) dans un dossier Audio.

  2. Dans le Blueprint, à la fin de votre logique d'attaque, ajoutez le nœud Play Sound at Location.

  3. Sound : Sélectionnez votre son de coup de poing.

  4. Location : Utilisez le nœud Get Actor Location (ou la location de l'impact si disponible).

3.2 Son aléatoire (Sound Cue)

Pour éviter que le même bruitage se répète à chaque fois (effet "mitraillette"), nous allons créer un conteneur intelligent.

  1. Dans le Content Browser, faites un clic droit > Audio > Sound Cue. Nommez-le SC_PunchRandom.

  2. Ouvrez le Sound Cue.

  3. Glissez vos différents fichiers sons (WAV) de coups de poing à l'intérieur.

  4. Ajoutez un nœud Random.

  5. Connectez vos sons (Wave Player) aux entrées du nœud Random.

  6. Connectez la sortie du Random au nœud Output.

    • Astuce : Vous pouvez aussi ajouter un nœud "Modulator" pour varier légèrement le pitch et le volume.

3.3 Intégration

  1. Retournez dans votre BP_ThirdPersonCharacter.

  2. Dans le nœud Play Sound at Location, remplacez le fichier WAV simple par votre nouveau SC_PunchRandom.

Résumé du flux final

  1. Le joueur appuie sur Attaque.

  2. Le Blueprint tire un chiffre au hasard (0, 1 ou 2).

  3. Selon le chiffre, une animation spécifique (Montage) est jouée.

  4. La durée de cette animation est enregistrée pour gérer le délai entre les coups.

  5. Un son est choisi aléatoirement dans le Sound Cue et joué à l'emplacement du joueur.

🚀 Poursuis tes apprentissages

Voici du contenu supplémentaires facultatif pour continuer d'apprendre :

Apprendre comment ouvrir et fermer des portes dans Unreal Engine 5
Comment ouvrir une porte en utilisant des boutons - Unreal Engine 5
Comment créer un système de course et d'endurance dans Unreal Engine 5
Comment créer un système de soin et de dégât avec une barre de vie dans Unreal Engine 5
Comment jouer de la musique en entrant dans un Trigger zone dans Unreal Engine 5
SCARY Jumpscare: Objects Come to Life in Unreal Engine 5
Tutoriel lampe de poche UE5
Comment Faire un Double Saut
Créer une IA Ennemi Simple dans Unreal Engine 5
Prendre des dégâts d'une IA ennemie - Unreal Engine 5.2
Prendre des dégâts de saut - Unreal Engine 5
Donner des dégâts à un ennemi - Unreal Engine 5





🛠️ Ressources

Voici quelques ressources pertinentes :

Apprendre le blueprint pour débutant
Le Blueprint Unreal Engine 4
How To Make An Automatic Sliding Door In Unreal Engine 5
Les bases de l'inventaire sur UE5
How To PACKAGE - Export Your UE5 GAME
Créer un Package et Exporter votre Jeu
Exporter de BLENDER vers UNREAL ENGINE 5
Créer Un Metahuman Qui Parle Avec ChatGPT Dans UE5

Atelier précédent

Atelier suivant

Create a free website with Framer, the website builder loved by startups, designers and agencies.