Pièges et dégâts

Les obstacles jouent un rôle essentiel dans la conception d'un jeu. Les obstacles et les pièges permettent d'ajouter des conséquences et d'augmenter la difficulté et la tension du joueur à mesure qu'il progresse dans une énigme ou un niveau. 

Dans cette partie de ce tutoriel, vous allez créer un piège à pointes et un piège à feu qui infligent des dégâts au joueur. Vous connecterez ensuite votre piège à feu et déclencherez les objets de jeu pour créer une nouvelle mécanique ainsi qu'une nouvelle énigme. 

Maintenant que le joueur peut subir des dégâts et perdre des PV, vous allez configurer une condition d'échec qui arrête et relance le jeu, donnant aux joueurs la possibilité de retenter leur chance. 

Avant de commencer

Assurez-vous de bien comprendre les concepts abordés dans les sections précédentes du cours Concevoir une aventure de type énigme :

• Les principes de base des blueprints, à savoir les variables, les fonctions, les graphiques d'événements et l'ajout de nœuds.

• L'utilisation des événements d'interface de blueprint pour qu'un interrupteur active un autre objet de jeu.

Vous devez disposer des ressources suivantes créées dans les tutoriels Créer une clé et Énigmes : interrupteurs et cubes :

• Matériau M_BasicColor et instance de matériau M_BasicColor_Red

• Interface de blueprint BPI_Interaction

• Classe de blueprint BP_Switch 

Créer un ensemble de classes de blueprint associées

Dans ce tutoriel, vous avez découvert les ressources de l'Unreal Engine qui exploitent l'héritage et les relations parent-enfant. L'héritage consiste à créer une nouvelle classe enfant qui réutilise et développe les fonctionnalités d'une classe parente existante. La classe enfant peut développer ces fonctionnalités sans altérer la classe parente. L'héritage vous fait gagner du temps en réutilisant des fonctionnalités utiles dans plusieurs ressources au lieu de les ajouter manuellement à chaque nouvelle ressource.

Les ressources de votre instance de matériau héritent des fonctionnalités de leurs matériaux parents. Dans de nombreux blueprints, vous avez créé des composants qui héritent des données de transformation d'un composant parent. 

Bien que les jeux utilisent des types d'obstacles différents, ceux-ci partagent souvent les mêmes fonctionnalités de base. Un blueprint de piège parent peut définir ces fonctionnalités communes, tandis que chaque blueprint de piège enfant étend ces fonctionnalités en ajoutant différents éléments visuels et comportements. 

Votre piège de base (parent) doit détecter les chevauchements de joueurs et utiliser la mécanique de jeu "dégâts" pour réduire progressivement le nombre de PV des joueurs. Vous devez ensuite créer des pièges enfants (ou en créer une sous-classe) pour enrichir les fonctionnalités du piège de base et ajouter des éléments visuels ou des comportements. Le piège à pointes ajoute des maillages statiques supplémentaires à son apparence et le piège à feu ajoute un effet et un comportement de feu qui active et désactive le feu.

Étant donné que votre niveau est encore au stade d'ébauche, concentrez-vous sur la création d'une version simplifiée de chaque piège qui donnera néanmoins une idée de la future conception visuelle.

Créer le blueprint du piège de base

Commencez par créer la classe de blueprint du piège de base, qui servira de parent et de fondement à vos pièges spécialisés.

Pour créer un blueprint qui définit des fonctionnalités de piège communes, procédez comme suit :

1. Dans le navigateur de contenu, accédez au dossier Contenu > AdventureGame > Concepteur > Blueprints et créez un nouveau dossier nommé Pièges.

2. Faites un clic droit sur ce dossier ou cliquez sur Ajouter et créez une nouvelle classe de blueprint.

3. Dans la fenêtre Choisir la classe parente, cliquez sur Acteur.

4. Nommez cette classe BP_TrapBase et ouvrez-la.

Ajouter des composants

Pour le piège de base, vous allez créer un maillage statique de blocage pour afficher les limites du piège. Tous les pièges doivent par ailleurs disposer d'un volume de collision pour savoir quand le joueur marche dessus.

Pour créer les composants physiques du piège de base, procédez comme suit :

1. Dans l'onglet Composants, cliquez sur Ajouter, puis recherchez et ajoutez la forme de maillage statique Cube.

2. Nommez le composant de maillage TrapBase.

3. Dans le panneau Détails, sous Transformation, définissez l'option Échelle du cube sur 2, 2, 0,1 pour créer une base carrée plane.

   

4. Dans l'onglet Composants, sélectionnez TrapBase, cliquez sur Ajouter, puis recherchez et sélectionnez un composant Collision de boîte.

5. Nommez le composant de collision TrapTrigger. Il s'agit du volume de collision que vous utiliserez pour détecter quand le joueur se tient sur le piège.

   Tout comme avec BP_Switch, joignez le composant de collision au maillage ; ainsi, si vous souhaitez modifier la taille du piège, la zone de déclenchement s'ajuste automatiquement.  

6. Dans le panneau Détails, sous Transformation, modifiez les propriétés suivantes pour créer une grande boîte de collision au-dessus du maillage de base :

   1. Définissez Emplacement sur 0, 0, 400.

   2. Définissez Échelle sur 1,5, 1,5, 12.

   

Ajouter des variables

Tous les pièges doivent aussi disposer de propriétés modifiables qui vous permettent de déterminer :

• si l'obstacle est actif ou inactif ;

• les dégâts que le piège inflige au joueur ;

• l'intervalle de dégâts, ou le temps entre les impacts.

Le piège doit enfin savoir qui est entré en collision avec lui.

Pour ajouter des propriétés communes au piège de base, procédez comme suit :

1. Dans l'onglet Mon blueprint, créez les variables suivantes :

   Nom de la variable	Type	Catégorie	Valeur par défaut
   Active	Boolean	Setup	True
   BaseDamage	Float	Setup	5,0
   DamageInterval	Float	Setup	1,0

      Après avoir créé une variable, compilez votre blueprint pour ajouter une valeur par défaut.

2. Cliquez sur l'icône d'œil de chaque variable pour que l'œil soit ouvert. Les trois variables deviennent modifiables et publiques.

3. Ajoutez une variable appelée OtherActor et définissez son type sur Acteur (référence d'objet).

   

Créer une fonction pour appliquer des dégâts

Maintenant que votre piège a ses propriétés de base, vous pouvez commencer à créer son comportement. Tous les pièges doivent réduire les points de vie (PV) du joueur à intervalles réguliers lorsque le joueur se trouve sur le volume de collision. 

L'Unreal Engine dispose de solutions intégrées pour de nombreuses mécaniques de jeu courantes, notamment pour infliger et subir des dégâts.

Pour le piège, vous utiliserez le nœud de fonction Apply Damage intégré. Pour organiser la logique de gestion des dégâts, vous allez créer votre propre fonction qui appelle Apply Damage sur tous les personnages qui touchent le piège si celui-ci est actif.

Pour créer une fonction qui applique des dégâts de piège au joueur, procédez comme suit :

1. Dans la section Fonctions, cliquez sur Ajouter. Nommez cette fonction fnApplyDamageToTargets et ouvrez son graphique.

2. Étant donné que vous souhaitez uniquement appliquer des dégâts lorsque le piège est activé et actif, ajoutez un nœud Branch dans lequel la condition est une référence (Get) à la variable Active.

   

3. Plus tard dans ce tutoriel, vous allez ajouter des PNJ ennemis afin de placer plusieurs acteurs simultanément dans le piège. Lorsque le piège est actif, une matrice de tous les acteurs qui touchent le piège est parcourue en boucle :

   1. Reliez la broche True du nœud Branch à un nœud For Each Loop.

   2. Pour l'entrée Matrice de la boucle, vous devez créer une matrice de tous les acteurs qui se chevauchent. L'Unreal Engine s'en charge pour vous ; il vous suffit d'ajouter un nœud Get Overlapping Actors (TrapTrigger). Ce nœud a pour cible une référence à TrapTrigger.

   3. Dans le nœud Get Overlapping Actors, définissez le paramètre Filtre de classe sur Personnage afin de pouvoir ajouter les PNJ et les joueurs dans la matrice.

      

4. Pour chaque élément de matrice, ou chaque itération de la boucle, appliquez la quantité de dégâts définie dans la variable BaseDamage à l'acteur dans cet élément de matrice. Pour ce faire, reliez un nœud Apply Damage à Corps de boucle.

   

   La fonction Apply Damage provient de la bibliothèque Game Statics de l'Unreal Engine. L'icône dans le coin supérieur droit indique que la fonction peut être utilisée dans les jeux en réseau et peut être exécutée sur le serveur.

5. Configurez le nœud Apply Damage :

   1. Pour la broche Acteur endommagé, reliez l'élément de matrice de la boucle.

   2. Pour la broche Dégâts de base, reliez une référence à la variable Dégâts de base.

   

6. Enregistrez et compilez votre blueprint.

Votre fonction fnApplyDamageToTarget terminée doit ressembler à ceci :

Créer un chronomètre qui inflige des dégâts au cours du jeu

Vous devez ensuite faire en sorte que le piège appelle la fonction Apply Damage à intervalles réguliers. Pour ce faire, vous allez utiliser l'une des fonctions de chronométrage de l'Unreal Engine pour créer un chronomètre. 

Dans ce blueprint, vous allez utiliser le nœud Set Timer by Function Name :

Ce nœud crée un chronomètre et associe une fonction à ce chronomètre de manière à ce que, lorsque le chronomètre expire, le nœud appelle la fonction et exécute toutes les actions correspondantes. 

Pour configurer un chronomètre au démarrage du jeu, procédez comme suit :

1. Accédez à l'onglet Graphique d'événements de BP_TrapBase. Supprimez les nœuds Event ActorBeginOverlap et Event Tick fournis.

2. Avant que le piège n'effectue des actions, vous devez vérifier s'il est actif. Dans le nœud Event BeginPlay, ajoutez un nœud Branch dans lequel la condition est une référence à la variable Active.

3. Dans la broche True du nœud Branch, créez un nœud Set Timer by Function Name.

4. Configurez le nœud Timer :

   1. Pour la broche Temps, reliez une référence à la variable DamageInterval.

      

   2. Cliquez sur la zone de texte en regard de Nom de la fonction et saisissez fnApplyDamageToTarget.

      Assurez-vous que le nom de la fonction est correct ; dans le cas contraire, la logique ne s'exécutera pas correctement.

   3. Activez le paramètre Mise en boucle.

5. Les nœuds Set Timer génèrent une valeur de retour appelée Indicateur de chronomètre qui fait office de numéro de suivi ou de contrôleur pour le chronomètre. Pour arrêter, mettre en pause ou relancer le chronomètre, vous devez référencer cet identificateur de chronomètre. Par conséquent, enregistrez-le dans une nouvelle variable :

   1. Dans le panneau Mon blueprint, créez une variable appelée TimerHandler. Définissez son type sur Indicateur de chronomètre.

   2. Ajoutez un nœud Set Timer Handler et reliez-le aux broches d'exécution et de valeur de retour de Set Timer by Event.

      

6. Lorsque l'Unreal Engine crée un chronomètre, celui-ci démarre immédiatement. Vous devez donc mettre le chronomètre en pause jusqu'à ce qu'un personnage marche sur le piège. Reliez un nœud Pause Timer by Handle et attribuez-lui votre indicateur de chronomètre.

   

7. Enregistrez et compilez votre blueprint.

Vous pouvez également créer des chronomètres à l'aide d'un nœud Set Timer by Event. Ici, vous utiliserez la liste d'actions de nœud pour ajouter un événement personnalisé en tant que délégué afin de lier des actions au chronomètre. 

Les événements personnalisés sont des blocs de logique nommés et réutilisables similaires aux fonctions. Contrairement à ces dernières, ils peuvent contenir des délais, des nœuds de chronologie et d'autres actions latentes. Vous devrez donc peut-être adopter cette méthode à mesure que votre jeu devient plus complexe.

Reliez la broche de délégué carrée d'un événement pour transmettre une référence de cet événement au nœud de chronomètre. Cette action ne déclenche pas l'événement, mais stocke l'événement et ses actions pour plus tard (à l'expiration de l'intervalle de temps).

Lancer et arrêter les dégâts

Vous avez créé et mis en pause le chronomètre de dégâts pour qu'il soit prêt. Vous allez maintenant configurer le chronomètre pour déclencher les dégâts lorsqu'un personnage marche sur le volume de collision du piège, et interrompre les dégâts lorsque le personnage quitte le volume.  

Pour ajouter une logique qui déclenche les dégâts, procédez comme suit :

1. Dans le panneau Composants, faites un clic droit sur le composant TrapTrigger, accédez à Ajouter l'événement et sélectionnez Add OnComponentBeginOverlap.

2. Après l'événement, reliez un nœud Set Other Actor pour enregistrer l'acteur qui se trouve sur le volume dans la variable.

3. Reliez l'événement à la broche du nœud Set, puis reliez les deux broches Autre acteur.

4. Reliez un nœud fnApplyDamageToTarget pour que le personnage subisse des dégâts immédiatement lorsqu'il entre en contact avec le piège.

   

5. Reliez un nœud Unpause Timer by Handle pour relancer le chronomètre et les intervalles de dégâts. Pour son entrée Indicateur, reliez une référence à la variable TimerHandler.

   

Pour ajouter une logique qui arrête les dégâts au fil du temps, procédez comme suit :

1. Faites un clic droit sur le composant TrapTrigger, puis accédez à Ajouter un événement > À la fin du chevauchement du composant.

2. Après l'événement, reliez un nœud Pause Timer by Handle en lui donnant à nouveau une référence à TimerHandler.

   

3. Enregistrez et compilez votre blueprint.

À présent, le piège crée, lance et met en pause un chronomètre de dégâts.

Le graphique d'événements BP_TrapBase final doit ressembler à ceci :

Pour en savoir plus sur les chronomètres et leur gestion, consultez la page Gameplay Timers.

Tester le piège de base

Pour tester le piège, ajoutez un message Print String pour indiquer à l'écran quand le piège inflige des dégâts. 

Pour afficher un message à l'écran indiquant que le piège fonctionne comme prévu, procédez comme suit :

1. Dans BP_TrapBase, accédez à l'onglet fnApplyDamageToTarget.

2. Dans le graphique de la fonction, reliez un nœud Print String après le nœud Apply Damage.

3. Définissez Dans la chaîne sur Joueur touché !

4. Cliquez sur la flèche en bas du nœud Print String pour afficher des options supplémentaires et définissez le paramètre Durée sur 5. Vous facilitez ainsi l'affichage des dégâts infligés au fil du temps.

   

5. Compilez et enregistrez le blueprint. Dans le navigateur de contenu, faites glisser une instance de BP_TrapBase dans votre niveau.

6. Testez le niveau en marchant sur le piège. Un nouveau message "Joueur touché !" doit apparaître toutes les secondes.

   

Créer une sous-classe du piège à pointes

Maintenant que vous avez terminé votre classe parente, il est temps de commencer à créer des sous-classes ! 

Vous allez commencer par créer un piège à pointes qui modifie l'apparence du piège de base en y ajoutant des formes. Si un piège plat n'a pas l'air dangereux, le joueur suppose qu'un objet pointu est susceptible de le blesser. 

Pour créer un piège à pointes, procédez comme suit :

1. Dans le navigateur de contenu, accédez au dossier Pièges, faites un clic droit sur BP_TrapBase et sélectionnez Créer une classe de blueprint enfant.

2. Nommez la classe de blueprint BP_TrapSpikes et ouvrez-la.

3. Dans l'onglet Composants, sélectionnez DefaultSceneRoot, cliquez sur Ajouter, puis recherchez et sélectionnez Cône.

   Vous pouvez redimensionner et placer les cônes de façon à disposer de quatre rangées de quatre cônes chacune (soit 16 cônes au total).

4. Dans le panneau Détails du cône, accédez à la section Transformation et modifiez les propriétés suivantes :

   1. Définissez le paramètre Emplacement sur -75, -75, 25.

   2. Définissez le paramètre Échelle sur 0,5, 0,5, 0,4.

   Vous observez maintenant une petite pointe dans le coin du maillage de base.

   

5. Pour ajouter un contraste visuel, dans la section Matériaux, utilisez le menu déroulant et définissez le matériau du cône sur M_BasicColor_Red.

6. Sélectionnez et dupliquez (Ctrl + D) le cône trois fois, en déplaçant chaque cône de 50 unités pour que tous s'alignent sur l'un des côtés du maillage de base.

   

   Vous pouvez repositionner les cônes dans le panneau Détails ou dans le hublot. Pour accélérer ces réglages avec le gadget, définissez les paramètres de fixation des déplacements sur 50 unités.

   

7. Maintenez la touche Ctrl appuyée pour sélectionner les quatre cônes et les dupliquer. Dans le panneau Composants, sélectionnez les quatre nouveaux cônes (ils possèdent le plus grand nombre de suffixes) et déplacez-les de 50 unités. Répétez cette opération à deux reprises pour créer une grille de cônes de 4 x 4.

   

8. Le joueur peut avoir du mal à s'extraire du piège en raison de l'inclinaison et des angles des pointes. Pour éviter que le joueur n'atterrisse entre les pointes, ajoutez un sol invisible au sommet de ces dernières :

   1. Dans l'onglet Composants, dupliquez le maillage DoorBase et nommez-le InvisFloor.

   2. Déplacez le sol vers le haut pour que seule l'extrémité des pointes soit visible au-dessus du sol.

      

   3. Dans le panneau Détails, accédez à la section Collision et assurez-vous que le paramètre Préréglages de collision est défini sur BlockAllDynamic. Ce paramètre empêche tous les acteurs de passer à travers le maillage.

   4. Dans la section Rendu, désactivez l'option Visible. Cette option masque le maillage dans les hublots et pendant le jeu.

      

9. Dans l'onglet Composants, sélectionnez le maillage TrapBase. Dans le panneau Détails, accédez à la section Rendu et activez l'option Masqué en jeu. Le maillage est ainsi visible dans le hublot, mais il est masqué pendant le jeu. Les pointes ne sont donc pas visibles.

10. Enregistrez et compilez votre blueprint.

La sous-classe du piège à pointes dispose de tous les comportements de votre piège de base. Elle affiche donc également le message "Joueur touché !" lorsque le piège est actif. Insérez une instance de BP_TrapSpikes dans votre niveau et testez-la.

Créer une sous-classe du piège à feu

Vous allez ensuite créer un piège qui étend le comportement du piège de base. Un piège à feu ajoute un obstacle que le joueur peut désactiver à l'aide d'un interrupteur. Il s'agit d'une mécanique de jeu que vous pouvez convertir en nouvelle énigme.

Dans le tutoriel Énigmes : interrupteurs et cubes, vous avez créé l'interface de blueprint BPI_Interaction, qui permet aux interrupteurs d'activer ou de désactiver d'autres objets dans le jeu. Vous pouvez également utiliser cette interface dans un blueprint de piège afin qu'un interrupteur puisse changer la variable Active du piège pendant le jeu.

Vous devez tout d'abord disposer d'un nouveau matériau à utiliser quand le piège est désactivé. 

Procédez comme suit pour créer un matériau sombre pour le piège à feu :

1. Dans le navigateur de contenu, accédez au dossier AdventureGame > Concepteur > Matériaux.

2. Faites un clic droit sur M_BasicColor et sélectionnez Créer une instance de matériau.

3. Nommez l'instance de matériau M_BasicColor_Black et ouvrez-la.

4. Développez Valeurs de paramètre de vecteur global, activez Couleur et cliquez sur le nuancier pour sélectionner le gris foncé (sRVB hexadécimal = 3D3B3BFF). Cette couleur rend mieux dans le jeu que le noir.

   

5. Enregistrez et fermez l'instance de matériau.

Pour créer une sous-classe du piège à feu, procédez comme suit :

1. Dans le navigateur de contenu, faites un clic droit sur BP_TrapBase et sélectionnez Créer une classe de blueprint enfant.

2. Nommez le blueprint BP_TrapFire et ouvrez-le.

   

3. Modifiez la couleur du maillage de base pour représenter un piège à feu. Sélectionnez le composant DoorBase puis, dans le panneau Détails, accédez à la section Matériaux et définissez le matériau sur M_BasicColor_Red.

   

4. Au-dessus du hublot, cliquez sur Paramètres de classe.

5. Dans le panneau Détails, accédez à la section Interfaces en regard de Interfaces implémentées, cliquez sur Ajouter, puis recherchez et sélectionnez BPI_Interaction.

   

   Dans le panneau Mon blueprint, les fonctions d'événement fnBPISwitchOff et fnBPISwitchOn apparaissent dans la section Interfaces.

6. Comme dans BP_Switch, configurez les matériaux personnalisables du piège à feu :

   1. Dans la section Variables du panneau Mon blueprint, créez deux variables nommées OffMaterial et OnMaterial.

   2. Définissez leur type sur Interface de matériau (référence d'objet).

   3. Cliquez sur l'icône d'œil pour les rendre publiques et modifiables.

   4. Définissez leur catégorie sur Configuration.

      

   5. Compilez et définissez les valeurs par défaut suivantes :

      • OffMaterial : M_BaseColor_Black

      • OnMaterial : M_BaseColor_Red

7. Enregistrez et compilez le blueprint afin de pouvoir utiliser les événements d'interface dans le graphique d'événements du piège.

Étendre le comportement du piège

De la même manière que vous avez créé la plateforme mobile dans le tutoriel Énigmes : plateformes mobiles, vous devez configurer le graphique d'événements du piège pour qu'il exécute les actions suivantes lorsqu'un interrupteur appelle fnBPISwitchOn et fnBPISwitchOff :

• Activer ou désactiver le piège.

• Modifier le matériau du piège.

Comme nous l'avons vu, la plateforme mobile doit commencer à bouger lorsque le joueur actionne l'interrupteur. Dans le cas du piège, c'est l'inverse : le piège s'active lorsque le niveau commence et doit se désactiver lorsque le joueur actionne l'interrupteur.

Pour ajouter une logique qui désactive les pièges à feu lorsque le joueur appuie sur un interrupteur, procédez comme suit :

1. Accédez à l'onglet Graphique d'événements du piège à feu. Dans le panneau Mon blueprint, accédez à la liste Interfaces et double-cliquez sur fnBPIButtonOn pour ajouter un nœud d'événement au graphique.

2. Les variables BP_TrapBase ne figurent pas dans le panneau Mon blueprint, mais vous pouvez y accéder depuis la liste d'actions du nœud. Faites glisser la broche d'exécution de Event fnBPISwitchOn, recherchez la variable Active, puis sélectionnez Set Active. Conservez la variable Active désactivée.

   

3. Après le nœud Set, reliez un nœud Set Material (TrapBase) (dans la section Rendu > Matériau de la liste d'actions).

4. Dans le nœud Set Material, reliez une référence à la variable OffMaterial à la broche Matériau.

   

Pour ajouter une logique qui active les pièges à feu si un interrupteur est désactivé, procédez comme suit :

1. Dans la section Interfaces, double-cliquez sur le nœud Event fnBPISwitchOff pour l'ajouter.

2. Après l'événement, reliez un nœud de variable Set Active, mais activez cette fois Active.

3. Après le nœud Set, reliez un nœud Set Material (TrapBase) et reliez une référence à OnMaterial.

   

4. Enregistrez et compilez votre blueprint.

Le graphique d'événements de votre piège à feu final doit ressembler à ceci :

Ajoutez une instance de BP_TrapFire dans votre niveau et testez-la.

Mettre à jour l'ATH avec les PV du joueur

Vous devez maintenant remplacer ces nœuds Print String par un réel retour visuel pour le joueur. Vous allez modifier votre ATH pour indiquer les PV du joueur en temps réel.

Ajouter une variable PV à l'ATH

Pour indiquer le nombre de PV du joueur de façon dynamique sur votre ATH, procédez comme suit :

1. Dans le navigateur de contenu, ouvrez le blueprint de widget WBP_PlayerHUD. Vérifiez que vous avez sélectionné la vue Concepteur.

2. Dans la hiérarchie, cliquez sur le widget txtHP. Dans le panneau Détails, activez le paramètre Est variable et supprimez 100 de la propriété Texte.

   

3. Accédez à la vue Graphique et configurez une nouvelle fonction qui définit la valeur de txtHP :

   1. Dans la section Fonctions, ajoutez une fonction nommée fnSetHP.

   2. Après avoir sélectionné la fonction, dans le panneau Détails, cliquez sur le bouton + en regard de Entrées.

   3. Nommez l'entrée NewHP et définissez son type sur Float.

      Vous modifierez ultérieurement le personnage joueur pour qu'il appelle cette fonction lorsqu'il subit des dégâts.

4. Dans le graphique de la fonction fnSetHP, après le nœud d'entrée de la fonction, reliez un nœud SetText (Text).

   

   Si vous ne trouvez pas un nœud dans la liste d'actions de nœud, désactivez l'option Sensible au contexte.

5. Configurez le nœud SetText (Text) :

   1. Pour la cible, reliez une référence à la variable txtHP. Il s'agit du widget de texte qui affiche les PV du joueur.

   2. Pour Dans le texte, reliez la broche d'entrée Nouveaux PV du nœud d'entrée de la fonction. L'Unreal Engine ajoute automatiquement un nœud To Text (Float) pour convertir la valeur.

      

   3. Enregistrez et compilez le blueprint de widget.

Le graphique final de la fonction fnSetHP doit ressembler à ceci :

Afficher les PV de départ du joueur 

Configurez toutes les variables de l'ATH disponibles avant de les afficher. Dans ce cas, dans la mesure où vous connaissez les PV de départ du joueur, vous pouvez afficher cette information au début du jeu.

Pour mettre à jour le blueprint du personnage joueur afin qu'il affiche ses PV dans l'ATH, procédez comme suit :

1. Dans le navigateur de contenu, ouvrez le blueprint BP_AdventureCharacter. Dans le graphique d'événements, recherchez la logique Événement possédé.

   

   Dans le panneau Mon blueprint, développez Graphiques > Graphique d'événements, puis double-cliquez sur Événement possédé pour le sélectionner dans le graphique.

2. Entre le nœud Set et le nœud Add to Viewport, reliez un nœud fnSetHP :

   1. Pour la cible, utilisez la broche de sortie du nœud Set pour convertir l'ATH en cible.

   2. Pour Nouveaux PV, reliez une référence à la variable PV du joueur.

      

3. Assurez-vous que la broche Cible du nœud Add to Viewport est également reliée au nœud de variable HUD.

4. Dans le panneau Mon blueprint, cliquez sur la variable PV. Dans le panneau Détails, modifiez ou conservez la valeur par défaut. Dans ce tutoriel, les points de vie de départ sont de 100.

5. Enregistrez et compilez le blueprint.

La nouvelle logique Événement possédé du joueur doit ressembler à ceci :

Désormais, l'ATH affiche les PV du joueur au démarrage du jeu. La dernière partie de la logique dont vous avez besoin consiste à mettre à jour l'ATH lorsque le joueur subit des dégâts. Pour ce faire, vous allez modifier la logique de gestion des dégâts du personnage pour qu'elle fonctionne avec votre ATH.

Mettre à jour les PV du joueur après que celui-ci subit des dégâts

Pour gérer les dégâts infligés au joueur, procédez comme suit :

1. Dans le coin inférieur gauche du graphique d'événements de BP_AdventureCharacter, recherchez la section de logique intitulée "Gestion des dégâts et des éliminations" qui commence par un nœud Event AnyDamage. Vous allez modifier cette section pour exécuter votre propre logique.

   

2. Supprimez tous les nœuds qui se trouvent après le nœud Branch, mais conservez le nœud Branch.

   

   Dans cette section de la logique, nous utilisons des nœuds d'opérateur pour effectuer des calculs. Lorsque le personnage subit des dégâts, le nœud Event AnyDamage se déclenche et transmet les informations sur les dégâts infligés, le type de dégâts ainsi que le contrôleur et l'acteur ayant infligé les dégâts. Les dégâts sont alors soustraits de la variable PV du personnage. Une fois les PV du joueur soustraits, le nœud Branch vérifie si les PV du joueur ont atteint la valeur 0.

3. Pour l'instant, vous pouvez créer une logique qui met à jour l'ATH lorsque les PV du joueur sont supérieurs à 0. Pour cela, depuis la broche False, reliez un nœud FnSetHP pour envoyer la nouvelle valeur de PV à l'ATH.

4. Configurez le nœud fnSetHP :

   1. Pour la cible, reliez une référence à la variable ATH du personnage.

   2. Pour l'entrée Nouveaux PV, reliez une référence à la variable PV.

      

5. Enregistrez et compilez votre blueprint.

L'ATH affiche désormais le nombre de PV actuel du joueur et le met à jour lorsque le joueur subit des dégâts.

Jouez à votre niveau pour le tester !

Créer une condition d'échec et de réapparition

Lorsque le joueur n'a plus de PV et est éliminé, vous devez arrêter le jeu et donner au joueur une chance de rejouer. Dans ce tutoriel, vous allez désactiver les contrôles du joueur, communiquer au joueur qu'il a perdu la partie et charger le niveau.

Vous allez commencer par créer un blueprint de widget de fin de partie pour informer le joueur qu'il a été éliminé.

Ajouter un écran de fin de partie

Procédez comme suit pour créer un blueprint de widget pour votre écran de fin de partie :

1. Dans le navigateur de contenu, accédez au dossier AdventureGame > Concepteur > Blueprints > Widgets, faites un clic droit dessus, accédez à Interface utilisateur et sélectionnez Blueprint de widget.

2. Dans la fenêtre Choisir la classe parente, cliquez sur Widget utilisateur.

3. Nommez le blueprint de widget WBP_EliminatedScreen et ouvrez-le.

Pour configurer l'interface de fin de partie, procédez comme suit :

1. Dans l'onglet Palette, recherchez la zone de dessin et faites glisser un panneau Zone de dessin sur [WBP_EliminatedScreen] dans la hiérarchie. Tout comme avec votre ATH, la zone de dessin est le widget racine.

2. La zone de dessin contient un message de fin de partie superposé à un effet de flou qui rend le texte plus lisible. Dans l'onglet Palette, faites glisser une superposition pour qu'elle devienne un enfant de la zone de dessin.

3. Une fois la superposition sélectionnée, dans le panneau Détails, accédez à la section Emplacement (emplacement du panneau Zone de dessin), développez Ancres et définissez les deux valeurs Maximum (X et Y) sur 1.

   Les autres propriétés d'emplacement (sous Ancres) sont remplacées par les paramètres de décalage.

   

   Lorsque vous avez créé l'ATH, vous avez conservé tous les points d'ancrage dans un coin afin que, en cas de changement de taille de l'écran, ces objets restent ancrés au point d'ancrage. La superposition est maintenant ancrée à l'ensemble de la boîte englobante de la zone de dessin de façon à ce qu'elle se rétracte ou s'étire en fonction de la taille de l'écran.

4. Lorsque vous avez modifié les paramètres d'ancrage, l'éditeur a modifié certaines valeurs de décalage afin de conserver la forme par défaut du panneau de superposition. Pour supprimer cela, définissez Décalage à droite et Décalage vers le bas sur 0. La superposition occupe désormais l'écran.

   

5. Dans l'onglet Palette, faites glisser un widget Flou d'arrière-plan pour qu'il devienne un enfant du panneau Superposition.

6. Une fois l'effet de flou sélectionné, dans le panneau Détails, accédez à la section Emplacement (emplacement de la superposition) et définissez les paramètres suivants :

   1. Alignement horizontal sur Remplir horizontalement.

   2. Alignement vertical sur Remplir verticalement.

      

7. Dans la section Apparence, définissez Force du flou sur 5.

8. Dans l'onglet Palette, ajoutez un widget de texte en tant qu'enfant de la superposition.

9. Une fois le widget Texte sélectionné, dans le panneau Détails, accédez à la section Emplacement (emplacement de la superposition) et définissez les paramètres suivants :

   1. Alignement horizontal sur Aligner horizontalement au centre.

   2. Alignement vertical sur Aligner verticalement au centre.

      

10. Dans la section Contenu, modifiez le texte en Vous vous êtes fait éliminer… redémarrage du niveau.

11. Dans la section Apparence, agrandissez le texte afin d'en améliorer la lisibilité en configurant les propriétés suivantes :

    1. Cliquez sur le nuancier en regard de Couleur et opacité et choisissez la couleur de votre texte. Dans ce tutoriel, nous utilisons le rose (couleur sRVB hexadécimal = FF4D7AFF).

    2. Développez l'en-tête Police et définissez le paramètre Taille sur 60. 

    3. Développez Police > Paramètres des contours et définissez le paramètre Taille du contour sur 1.

       

12. Enregistrez et compilez votre blueprint.

Créer une logique pour une condition d'échec

Maintenant que vous disposez d'un écran de fin de partie, vous pouvez modifier la classe de personnage en vue de l'afficher lorsque le joueur n'a plus de points de vie. Lorsque cela se produit, l'exécution passe par le résultat True du nœud Branch sur lequel vous travailliez précédemment.

Pour gérer l'élimination du joueur, vous devez : 

• Désactiver les commandes du joueur pour que le joueur ne puisse pas bouger.

• Afficher l'écran de fin de partie.

• Redémarrer le niveau après un délai défini.

Pour arrêter et charger la partie lorsque le joueur est éliminé, procédez comme suit :

1. Dans BP_AdventurePlayer, revenez à la logique de gestion des dégâts (en commençant par Event AnyDamage) dans votre blueprint de personnage.

2. Après la broche d'exécution du nœud Branch, reliez un nœud Do Once et un nœud Disable Input.

   

   Le joueur peut continuer à subir des dégâts même s'il est à court de PV. Le nœud Do Once permet donc de s'assurer que la logique qui suit ne s'exécute qu'une seule fois.

3. Pour la broche Contrôleur de joueur du nœud Disable Input, reliez un nœud Get Player Controller (dans la section Jeu > Joueur de la liste d'actions de nœud).

   

   Certains nœuds sont nommés Get Player Controller. Vérifiez que le nœud comporte une broche d'entrée Index de joueur. L'index 0 est l'index par défaut du premier personnage joueur qui apparaît dans le niveau.

4. Après avoir désactivé le contrôleur de joueur, créez et affichez l'écran de fin de partie :

   1. Reliez un nœud Create Widget. Dans le nœud, définissez la classe sur WBP_EliminatedScreen.

      

   2. Reliez la broche d'exécution et la broche Valeur de retour du nœud de widget à un nœud Add to Viewport.

      

5. Ajoutez un délai, obtenez le nom du niveau actuel, puis chargez ce niveau :

   1. Après le nœud Add to Viewport, reliez un nœud Delay et définissez le paramètre Durée sur 5 secondes.

   2. Après le nœud Delay, reliez un nœud Get Current Level Name.

   3. Après le nœud Get Current Level Name, reliez un nœud Open Level (by Name).

   4. Reliez la broche Valeur de retour à la broche Nom du niveau. L'éditeur ajoute automatiquement un nœud de conversion de chaîne en nom.

      

6. Enregistrez et compilez votre blueprint de joueur.

Cette section du graphique d'événements BP_AdventureCharacter doit désormais ressembler à ceci :

Jouez à votre niveau pour le tester. Marchez sur un piège, laissez votre personnage perdre tous ses PV et assurez-vous que le jeu est correctement réinitialisé.

Ajouter des obstacles à vos énigmes 

Dans le tutoriel Énigmes : Interrupteurs et cubes, vous avez appris à concevoir des mécaniques de jeu qui ajoutent de la difficulté, de la tension, des conséquences et des décisions risquées. Les obstacles du décor qui infligent des dégâts au joueur sont l'une des mécaniques qui engendrent ces conséquences. Vous pouvez utiliser les pièges à pointes pour ajouter des dangers et conséquences supplémentaires aux énigmes et obstacles situés au début du niveau. Les pièges à feu déclenchés par un interrupteur permettent par ailleurs de créer des énigmes plus dynamiques qui obligent le joueur à interagir avec le décor pour découvrir des itinéraires sûrs.

Lors de la conception de jeux, pour réduire les coûts de mémoire et accélérer le développement, vous devez trouver différentes façons d'utiliser et de combiner les objets de jeu. Dans une section précédente de ce tutoriel, nous avons vu comment déclencher des plateformes à l'aide d'un interrupteur pour parcourir un niveau. Ici, le même interrupteur peut désactiver les pièges à feu pour révéler un itinéraire au joueur. Vous augmentez ainsi la diversité de votre niveau sans avoir besoin d'un nombre incalculable de systèmes uniques. 

À l'instar de la mécanique de jeu "porte et clé" que vous avez créée plus tôt dans cette série de tutoriels, le piège à feu est une autre mécanique permettant de gérer le rythme du joueur et son accès à l'environnement.

Créer un jeu d'énigme de labyrinthe avec des pièges à feu

Dans la pièce 2, vous allez combiner des interrupteurs et des pièges à feu pour créer un labyrinthe dans lequel le joueur doit désactiver des obstacles avec précaution pour découvrir et récupérer la dernière clé. 

Il est souvent utile de commencer par esquisser les énigmes sur papier. Étant donné que les pièges font 1 mètre sur 1 mètre, notre pièce 2 peut contenir une grille de pièges de 7 x 9. Commencez par dessiner un itinéraire qui parcourt la grille et se termine à la clé. Ensuite, divisez l'itinéraire en segments et placez des interrupteurs pour contrôler chaque segment.

Pour ajouter de la difficulté et créer plus de surprises, ajoutez des fonctionnalités architecturales qui bloquent la visibilité. Placez par exemple des interrupteurs derrière les murs ou les piliers afin que le joueur puisse les découvrir en cours de chemin.  

Cette boucle permet au joueur d'apercevoir la clé afin qu'il découvre l'objectif tout en parcourant le premier segment de l'itinéraire.

Une fois votre plan terminé, commencez à ébaucher l'énigme dans l'éditeur de niveau. 

Après avoir créé les nouvelles formes et l'itinéraire menant à la clé, remplissez le reste de la pièce de pièges à feu pour masquer l'itinéraire correct. 

Si vous le souhaitez, vous pouvez aider le joueur à trouver l'issue lorsqu'il a terminé l'énigme en ajoutant un dernier interrupteur sous la clé qui désactive certains pièges le long du chemin de sortie.   

Testez fréquemment votre énigme en prenant en compte les lignes de vue, les points de frustration et les raccourcis possibles. Demandez à un ami de vous aider afin de détecter de possibles failles auxquelles vous n'auriez pas pensé. Pendant le test, il est possible que vous deviez procéder à des ajustements pour empêcher ou dissuader le joueur d'ignorer certaines parties de l'énigme. 

Si vous découvrez une faille, plusieurs options s'offrent à vous :

• Réorganiser l'itinéraire ou l'énigme.

• Ajouter des obstacles architecturaux supplémentaires.

• Augmenter les dégâts de feu afin que s'écarter de l'itinéraire ait des conséquences plus sévères.

Laisser une faille en augmentant la sévérité des conséquences donne au joueur plus de choix et d'autonomie. Le joueur peut choisir de passer plus de temps à découvrir l'itinéraire le plus sûr ou de sacrifier ses PV pour accéder plus rapidement à la clé.

Dans l'énigme de l'exemple de niveau, nous avons ajouté des gravats sous la voûte menant à la clé pour que le joueur puisse la voir, sans toutefois pouvoir y accéder directement. Nous avons également masqué les interrupteurs afin d'offrir des surprises gratifiantes, mais aussi pour éviter de passer outre cette partie de l'itinéraire.

Ajouter des pointes aux obstacles précédents

Nous allons maintenant ajouter des pointes aux énigmes précédentes pour que les chutes aient des conséquences.

Commençons par l'énigme de la première pièce. Pour la première plateforme mobile, ne placez pas la barre trop haut afin que si le joueur tombe, il puisse remonter dessus et réessayer. Lorsque vous créez une nouvelle mécanique, donnez au joueur la possibilité d'apprendre dans un environnement sûr afin qu'il puisse se concentrer sur son apprentissage.

De la même manière, dans la salle de départ, vous pouvez ajouter des pointes dans la fosse sous la première clé. Le joueur peut s'entraîner à sauter sur les deux premières plateformes pour se préparer au dernier saut vers la clé, plus risqué. Récupérer la première clé sans encombre suscite alors un peu plus d'intérêt !

Une fois que le joueur comprend les bases et s'est entraîné à déplacer des blocs sur des plateformes et des interrupteurs, vous pouvez ajouter des conséquences. Placez des pièges à pointes sous la deuxième plateforme ou le troisième bouton. Vous avez maintenant augmenté la tension d'un cran, car le joueur subit des dégâts lorsqu'il tombe, mais peut rapidement s'éloigner du piège pour minimiser ces dégâts et poursuivre la partie. 

Enfin, continuez à augmenter le risque pour la dernière plateforme et le dernier interrupteur. Couvrez la zone inférieure avec des pointes afin que le joueur soit obligé de courir encore plus loin pour échapper aux pointes et subisse ainsi davantage de dégâts. À ce stade, le joueur doit mieux maîtriser la mécanique, et les conséquences suite aux erreurs semblent plus justes, car il s'est déjà entraîné.

Cette conception suit cette structure populaire pour présenter les mécaniques de jeu aux joueurs : 

1. Présenter : la première plateforme permet d'apprendre la mécanique de jeu en toute sécurité.

2. Développer : la deuxième plateforme et le deuxième cube testent les compétences accrues du joueur avec un risque moyen.

3. Corser : la dernière plateforme augmente le danger et ajoute une nouvelle direction de déplacement, transformant la mécanique en défi intense.

Comme vous l'avez appris dans le tutoriel Énigmes : plateformes mobiles, en multipliant les conséquences tout au long de l'énigme, vous trouvez un compromis entre équilibre et divertissement.

Modifier les dégâts d'un piège

Vous pouvez décider de changer le niveau de difficulté en augmentant ou en réduisant les dégâts d'un type de piège. Pour cela, vous pouvez utiliser l'une des deux méthodes suivantes :

• Dans l'organiseur, recherchez "pointes" ou "feu" et sélectionnez tous les pièges du type correspondant. Dans le panneau Détails, sélectionnez Configuration > Dégâts de base. Si vous ajoutez cette méthode, vous devez également modifier les dégâts de base de chaque nouvelle instance du piège que vous ajoutez dans votre niveau. Vous pouvez aussi ajouter de nouvelles instances de pièges au niveau en dupliquant des pièges existants pour éviter d'avoir à modifier chaque nouvelle instance.

  

  OU

• Ouvrez l'un des blueprints de piège enfants et accédez à l'onglet Script de construction. Vous ne pouvez pas modifier les variables héritées dans le panneau Mon blueprint, mais pouvez définir des variables dans le graphique. Après les deux nœuds Construction Script, reliez un nœud Set Base Damage. Dans ce dernier, modifiez la valeur Dégâts de base selon vos préférences.

  

Pour que vos objets de jeu soient prévisibles pour le joueur, veillez à ce que tous les pièges d'un même type infligent les mêmes dégâts. 

Dans l'exemple de niveau du tutoriel, les pièges à feu infligent 5 dégâts par seconde et les instances du piège à pointes sont modifiées afin d'infliger 10 dégâts par seconde.

Tester l'exemple de niveau 

Si vous souhaitez utiliser des éléments de la pièce conçus dans cette partie du tutoriel au lieu de créer les vôtres, copiez les extraits ci-dessous.

Ébauche de la pièce 2

Cet extrait de texte contient le sol, les murs et les nouvelles ébauches de formes de la pièce 2. Dans l'organiseur, toutes les formes se trouvent dans le dossier Room2.

Begin Map
   Begin Level
      Begin Actor Class=/Script/Engine.TextRenderActor Name=TextRenderActor_19 Archetype="/Script/Engine.TextRenderActor'/Script/Engine.Default__TextRenderActor'" ExportPath="/Script/Engine.TextRenderActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19'"
         Begin Object Class=/Script/Engine.TextRenderComponent Name="NewTextRenderComponent" Archetype="/Script/Engine.TextRenderComponent'/Script/Engine.Default__TextRenderActor:NewTextRenderComponent'" ExportPath="/Script/Engine.TextRenderComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19.NewTextRenderComponent'"
         End Object
         Begin Object Class=/Script/Engine.BillboardComponent Name="Sprite" Archetype="/Script/Engine.BillboardComponent'/Script/Engine.Default__TextRenderActor:Sprite'" ExportPath="/Script/Engine.BillboardComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19.Sprite'"
         End Object
         Begin Object Name="NewTextRenderComponent" ExportPath="/Script/Engine.TextRenderComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.TextRenderActor_19.NewTextRenderComponent'"
            Text=NSLOCTEXT("[3C535F7772EB3B3657484B5E2D5B925D]", "2347F80B407C68C27836E990A20143CF", "Room 2")
            HorizontalAlignment=EHTA_Center

Pour copier toutes les ébauches de la pièce 2, procédez comme suit :

1. Supprimez tout ce qui se trouve déjà dans la pièce 2 (ou ce qui se trouve à la fin du couloir 2) :

   • Utilisez l'organiseur pour sélectionner les contenus existants de la pièce 2 : faites un clic droit sur le dossier Room2 et cliquez sur Sélectionner > Enfants immédiats. Appuyez ensuite sur Suppr.

   • Vous pouvez également basculer le hublot vers la vue orthographique supérieure pour sélectionner et supprimer manuellement la pièce existante.

2. Cliquez sur Copier l'extrait complet.

3. Dans l'Unreal Editor, assurez-vous que le hublot est le panneau actif (cliquez n'importe où dans le hublot ou l'organiseur, puis appuyez sur Échap) et appuyez sur Ctrl + V.

Votre niveau et l'organiseur doivent ressembler à ceci :

Interrupteurs, pièges et clés de la pièce 2

Cet extrait de texte contient les interrupteurs, les pièges et la clé rouge de l'énigme. Dans l'organiseur, tous les objets se trouvent dans un dossier appelé Room2.

Begin Map
   Begin Level
      Begin Actor Class=/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C Name=BP_FireTrap_C_261 Archetype="/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.Default__BP_TrapFire_C'" ExportPath="/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261'"
         Begin Object Class=/Script/Engine.SceneComponent Name="DefaultSceneRoot" Archetype="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C:ICH-DefaultSceneRoot_GEN_VARIABLE'" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.DefaultSceneRoot'"
         End Object
         Begin Object Class=/Script/Engine.StaticMeshComponent Name="TrapBase" Archetype="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C:TrapBase_GEN_VARIABLE'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.TrapBase'"
         End Object
         Begin Object Class=/Script/Engine.BoxComponent Name="TrapTrigger" Archetype="/Script/Engine.BoxComponent'/Game/AdventureGame/Designer/Blueprints/Traps/BP_TrapFire.BP_TrapFire_C:TrapTrigger_GEN_VARIABLE'" ExportPath="/Script/Engine.BoxComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.TrapTrigger'"
         End Object
         Begin Object Name="DefaultSceneRoot" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_FireTrap_C_261.DefaultSceneRoot'"

Pour configurer les blueprints de l'énigme, procédez comme suit : 

1. Cliquez sur Copier l'extrait complet.

2. Dans l'Unreal Editor, assurez-vous que le hublot ou l'organiseur est le panneau actif, puis appuyez sur Ctrl + V.

3. Vérifiez les propriétés de configuration de chaque interrupteur et, si nécessaire, reconnectez chaque interrupteur à ses pièges à feu :

   1. Dans l'organiseur, accédez au dossier Room2 et cliquez sur BP_Switch4.

   2. Dans le panneau Détails, sous la section Configuration, développez la liste des objets d'interaction.

   3. En regard de chaque élément de la liste, cliquez sur le menu déroulant, recherchez S4 et sélectionnez l'un des pièges à feu marqués S4.

      

   4. Répétez ces étapes pour chaque interrupteur :

      • BP_Switch5 déclenche BP_FireTrap_S5_0-7

        

      • BP_Switch6 déclenche BP_FireTrap_S6_0-3

        

      • BP_Switch7 déclenche BP_FireTrap_S7_0-4

        

      • BP_Switch8 déclenche BP_FireTrap_S8_0-3

        

      • BP_Switch9, sous la clé, déclenche BP_FireTrap_S9_0-4

        

Votre niveau et l'organiseur doivent ressembler à ceci :

Suivant

Vous apprendrez ensuite à ajouter un autre obstacle populaire à votre jeu : les PNJ ennemis ! Apprenez à créer un personnage IA ennemi et à ajouter un maillage de navigation dans votre niveau pour que les ennemis trouvent le joueur et lui infligent des dégâts.

• 

  Créer un ennemi

  Concevoir une logique de jeu pour créer des personnages ennemis qui infligent et subissent des dégâts.