Ouvrir des portes avec des clés

Maintenant que le joueur peut récupérer des clés dans le jeu, ajoutez une fonctionnalité permettant de déverrouiller des portes et de les ouvrir lorsque le joueur a ramassé la clé requise. Dans cette partie du tutoriel, vous modifierez le blueprint BP_DoorFrame et découvrirez les fonctions disponibles dans les blueprints.

Les portes déverrouillables permettent de contrôler le flux du jeu et de donner une impression de progression au joueur. Le projet sur lequel nous travaillons actuellement est divisé en plusieurs salles. Ainsi, ramasser des clés pour déverrouiller les portes constitue un chemin de progression logique pour le joueur.

Avant de commencer

Assurez-vous de bien comprendre les sujets abordés dans les sections précédentes de la série de tutoriels Concevoir une aventure de type énigme :

• Bases des blueprints, notamment les interfaces de blueprint.

• Créer des variantes d'un objet à l'aide d'une variable Mappage.

Vous aurez besoin des ressources suivantes, créées lors du tutoriel précédent : Créer une clé :

• BP_Key

• Bibliothèque de fonctions de blueprint BPL_FPGame

• Interface de blueprint BPI_PlayerKeys

• Trois instances de BP_DoorFrame placées dans votre niveau entre des salles ou des couloirs.

Ajouter des options de couleur à la porte

Étant donné que le modèle à la première personne dispose déjà d'un blueprint de porte, vous pouvez modifier le blueprint existant pour ajouter la fonctionnalité permettant de déverrouiller les portes avec une clé. 

Votre porte nécessite quelques éléments pour fonctionner avec le système de clés que vous avez défini dans la partie précédente de ce tutoriel. Tout comme la clé, votre porte doit savoir que l'acteur qui interagit avec elle implémente l'interface BPI_PlayerKeys. 

La porte doit changer de couleur pour correspondre à celle de la clé qu'elle accepte. Le joueur doit donc savoir quel type de clé peut la déverrouiller. Enfin, elle a besoin de la même variable KeyMap avec des combinaisons de couleurs rouge, jaune et bleu.

Créer des variables pour interagir avec le joueur et les clés

Pour ajouter de nouvelles variables au blueprint BP_DoorFrame, procédez comme suit.

1. Accédez au navigateur de contenu, atteignez le dossier LevelPrototyping > Interactif > Porte, et ouvrez le blueprint BP_DoorFrame.

2. Accédez au panneau Mon Blueprint puis à la section Variables, et ajoutez une nouvelle variable nommée UseKey de type booléen. Elle détermine si la porte s'ouvre avec une clé.

3. Créez une nouvelle variable nommée RequiredKey de type Type de clé d'enum. Elle détermine la clé requise pour ouvrir la porte. 

   

4. Cliquez sur l'icône d'œil en regard des deux variables pour la convertir en icône d'œil ouvert, qui indique que les variables sont modifiables.

5. Sélectionnez la variable UseKey. Dans le panneau Détails, spécifiez Configuration comme catégorie.

6. Sélectionnez RequiredKey et remplacez sa catégorie par Configuration.

7. Créez une nouvelle variable nommée Autre acteur de type Acteur > Référence d'objet. Cette action permet de stocker l'acteur qui interagit avec la porte ; vous l'utiliserez pour vérifier si le joueur a pénétré dans le volume de porte.

   

Créer la variable de mappage des clés

Tout comme vous l'avez fait dans BP_Key, vous allez ajouter la variable de mappage qui associe les types de clés aux couleurs des matériaux. Cependant, avec la porte, vous ne voulez pas que les maillages de porte changent de forme, donc vous n'ajouterez pas de nouvelles formes de maillage au mappage.

Pour créer la variable KeyMap de la porte, procédez comme suit :

1. Créez une variable nommée KeyMap, de type Type de clé d'enum. 

2. Cliquez sur cette variable, et dans le panneau Détails, cliquez sur le menu déroulant Conteneur et sélectionnez Mappage. 

3. Changez le type de valeur du mappage en Données de clé de structure.

   

4. Compilez le blueprint pour ajouter des valeurs de KeyMap.

5. Dans la section Valeur par défaut du mappage, ajoutez (+) 3 nouveaux éléments au mappage de clé. 

   Lorsque vous ajoutez la première entrée, modifiez le type en une autre couleur pour pouvoir continuer à ajouter de nouvelles entrées. Vous ne pouvez ajouter la même entrée d'une fois.

   

6. Pour chaque élément de mappage, ajoutez le matériau de clé correspondant :

   1. M_BasicColor_Yellow

   2. M_BasicColor_Red

   3. M_BasicColor_Blue

   

7. Pour chaque élément, assurez-vous que le maillage de clé est défini sur Aucun. Pour supprimer un maillage, cliquez sur le menu déroulant et sélectionnez Effacer en haut de la liste. 

8. Enregistrez et compilez le blueprint de la porte.

Ajouter la logique de blueprint de changement de couleur

Une fois les variables configurées, vous pouvez ajouter la fonctionnalité de changement de couleur en modifiant le graphique de blueprint.

Tout d'abord, vous devez modifier la porte pour lui donner les options de couleurs rouge, bleu et jaune contrôlées par la nouvelle variable RequiredKey que vous avez ajoutée. La porte doit changer de couleur lorsque vous la configurez dans le niveau, pas lorsque le jeu commence. Vous devrez donc utiliser l'onglet Script de construction pour créer cette fonctionnalité. 

Pour ajouter les options de couleur de la porte, procédez comme suit :

1. Atteignez l'onglet Script de construction de la porte, dans lequel vous pouvez créer une fonctionnalité pour celle-ci à sa création. Dans le graphique, recherchez le nœud violet Construction Script qui lance la logique de cette fonction.

2. Dans le nœud Sequence qui est connecté au nœud Construction Script, utilisez la broche Ajouter (+) pour créer une autre broche appelée Then 2, que vous pouvez utiliser pour construire la chaîne.

   

   Le nœud Sequence permet de construire une séquence d'actions, où la valeur de Then 0 est exécutée en premier, suivi de celle de Then 1, etc., en fonction du nombre de broches que vous choisissez d'ajouter. Elles permettent d'organiser le graphique et d'éviter qu'une chaîne de logique ne devienne trop longue.

3. Faites glisser la broche Then 2 dans une partie vide du graphique et créez un nœud Branch. 

4. Faites glisser la broche Condition du nœud Branch et créez un nœud Get Use Key. La branche vérifie maintenant si la porte doit utiliser des clés ou non. 

   

5. Faites glisser la broche True du nœud Branch et créez un nœud Fn BPLSet Key. Il s'agit de la fonction de bibliothèque qui applique une nouvelle couleur de matériau (et un maillage, s'il est fourni) à une matrice de maillages statiques.

6. Faites glisser la broche Matrice de maillages statiques du nœud Fn BPLSet Key et créez un nœud Make Array. 

7. Cliquez sur le bouton Ajouter une broche (+) dans le nœud Make Array.

8. À partir du nœud Make Array, faites glisser la première broche, [0], et créez un nœud Get Door. 

   Si vous regardez la liste Variables > Composants dans le panneau My Blueprint, vous constaterez que la porte comporte des composants de maillage statique Porte et Porte2. Il s'agit des éléments dont nous souhaitons changer la couleur.

9. Faites glisser la deuxième broche, [1], et créez un nœud Get Door 2. Cette opération crée une matrice sur la base des deux composants de maillage statique, Porte et Porte 2. 

10. Depuis le nœud Fn BPLSet Key, faites glisser la broche Mappage de clé et créez un nœud Get Key Map. Il s'agit d'une référence à la variable KeyMap de la porte.

11. Ensuite, faites glisser la broche Clé et créez un nœud Get Required Key, qui est une référence à la variable RequiredKey que vous avez ajoutée précédemment.

12. Compilez et enregistrez le blueprint.

Le script de construction de la porte devrait maintenant comprendre les éléments suivants après la broche Then 3 du nœud Sequence  :

Cette logique peut être copiée ; en voici une version :

Tester les couleurs de porte

Après avoir attribué une couleur à l'objet de porte, vous pouvez configurer les portes pour qu'elles ne s'ouvrent que si le joueur possède la clé correspondante.

Dans votre niveau, sélectionnez une instance de BP_DoorFrame.

Dans le panneau Détails, saisissez Clé dans le champ de recherche en haut. Cela révèle deux options : Utiliser une clé et Clé requise. Remplacez la clé requise par un type de clé différent. La couleur de la porte doit changer pour correspondre au type de clé.

À titre de rappel, c'est là l'avantage d'utiliser l'onglet Script de construction du graphique dans l'éditeur de blueprint. Vous pouvez observer les modifications directement dans l'éditeur de niveau, sans avoir à passer en mode de jeu.

Créer une logique de porte basée sur des clés

Créez ensuite la fonctionnalité qui permet de vérifier les clés détenues par le joueur. Pour cela, vous allez définir une fonction personnalisée nommée fnHasKey dans le blueprint BP_DoorFrame, permettant de vérifier si le joueur dispose de la clé requise.   

Créer une fonction qui vérifie les clés

Cette fonction compare la clé requise pour la porte avec la matrice de clés du personnage joueur et renvoie une valeur true ou false (booléenne). Vous utiliserez une variable locale pour cette valeur de retour booléenne.

Pour créer une fonction avec une variable locale, procédez comme suit :

1. Dans le blueprint BP_DoorFrame, accédez au panneau Mon Blueprint, puis cliquez sur Ajouter (+) en regard de la section Fonctions. Ceci est similaire à l'ajout d'une variable, sauf que vous ajoutez une fonction. 

2. Nommez la nouvelle fonction fnHasKey. 

   

3. Étant donné qu'une fonction peut avoir son propre ensemble de nœuds, elle s'ouvre dans son propre onglet fnHasKey avec un graphe de nœud distinct. Si vous fermez cet onglet et devez le rouvrir, double-cliquez sur la fonction dans la liste Fonctions.

4. Dans le panneau My Blueprint, vous verrez une nouvelle section en bas appelée Variables locales (FnHasKey). Créez une variable locale en cliquant sur Ajouter (+) à côté de cette section. 

5. Nommez la variable HasRequiredKey et définissez son type sur Booléen.

   

   Les variables locales sont similaires aux variables normales, mais elles sont locales à une fonction spécifique. Ces nœuds sont utiles pour stocker des valeurs temporaires pendant l'exécution de la fonction. Vous pouvez ensuite transmettre cette valeur au reste du blueprint à l'aide d'un nœud Return.

Une fois la fonction configurée, vous pouvez ajouter une logique qui vérifie si le joueur possède la bonne clé.

Pour vérifier si l'acteur situé dans le volume de la porte dispose de la clé requise, procédez comme suit :

1. Faites glisser la broche du nœud d'entrée de la fonction fnHasKey et créez un nœud Sequence. Cela permet d'organiser la logique de la fonction en une séquence d'actions exécutées dans un ordre donné.

2. Faites glisser la broche Then 0 du nœud Sequence et créez un nœud Fn BPIGet Keys (message). Il s'agit de la fonction d'interface qui renvoie une matrice des clés que le joueur a déjà trouvées.

3. Faites glisser la broche Cible du nœud Fn BPIGet Keys et créez un nœud Get Other Actor. Une fois le graphique événement de la porte configuré, cette variable permet de stocker l'acteur qui chevauche le volume de la porte.

   

4. Faites glisser la variable locale HasRequiredKeys près du nœud Fn BPIGet Keys et sélectionnez Set.

5. Faites glisser la broche Exec du nœud FN BPIGet Keys et connectez-la à la broche Set du nœud HasRequiredKey.

6. Depuis le nœud Set HasRequiredKey, faites glisser la broche HasRequiredKey et créez un nœud Contains Item, répertorié dans la section Matrice de la recherche. Ce nœud vérifie si un élément spécifique se trouve dans une matrice et renvoie true ou false.

   Vous pouvez également rechercher Matrice contenant l'élément pour affiner la recherche à cette option spécifique.

7. Depuis le nœud Content Item, faites glisser la broche Matrice cible (la broche carrée) et connectez-la à la broche Clés détenues du nœud Fn BPIGet Keys. 

8. Faites glisser la broche Objet à trouver (qui ressemble à un cercle) du nœud Contains Item, puis créez un nœud Get Required Key.

  Voici à quoi doit ressembler le graphique de votre fonction à ce stade :

Cette séquence d'actions vérifie si les clés détenues par OtherActor (variable) contiennent la RequiredKey (variable). Si oui, elle définit HasRequiredKey sur true. 

Transmettez maintenant le résultat de HasRequiredKey au reste du blueprint. Pour ce faire, utilisez un nœud Return, qui arrête l'exécution d'une fonction et renvoie une valeur au blueprint qui a appelé la fonction. 

Pour terminer la fonction avec un nœud Return, procédez comme suit :

1. À partir du nœud Sequence, faites glisser la broche Then 1, recherchez Return dans la liste des actions du nœud et sélectionnez Ajouter un nœud Return.

2. Pour que la fonction renvoie une valeur, elle a besoin d'une sortie. Cliquez sur le nœud Return pour la mettre en lumière d'accentuation.

3. Dans le panneau Détails, cliquez sur Ajouter (+) près de la section Sorties en bas. Cela ajoute une nouvelle sortie, qui est la valeur transmise par cette fonction.

4. Nommez cette sortie KeyFound et remplacez son type par Booléen.

5. Revenez dans le graphique, faites glisser la broche Clé trouvée du nœud Return et créez un nœud Get HasRequiredKey.

Le graphique complet de la fonction FnHasKey doit maintenant ressembler à ceci :

Verrouiller et déverrouiller des portes avec des clés

Vous pouvez maintenant modifier l'ouverture de la porte si toutes les conditions nécessaires sont remplies. 

À l'instar de la clé, vous devrez vérifier si le personnage implémente l'interface BPI_PlayerKeys (le "laissez-passer" du joueur) avant qu'il ne puisse essayer d'ouvrir une porte utilisant des clés.

Avant son ouverture, la porte doit vérifier les conditions suivantes :

• La porte est configurée de manière à utiliser des clés (UseKey = True).

• L'acteur en chevauchement est le joueur (il implémente BPI_PlayerKeys).

• Le joueur a le type de clé nécessaire.

Pour vérifier si l'acteur qui interagit avec la porte est le joueur, procédez comme suit :

1. Dans le graphique d'événements de BP_DoorFrame, recherchez le nœud Event ActorBeginOverlap. Cette collection de nœuds contrôle ce qui doit se passer quand un personnage entre dans le volume de collision de la porte. Ajoutez une interface de blueprint et une exigence de clé à cette logique afin que la porte ne s'ouvre que si l'acteur est le joueur et qu'il dispose de la bonne clé. 

   Vous pouvez utiliser Ctrl + F pour rechercher le nom d'un nœud. Cliquez sur le résultat de la recherche pour y accéder directement.

2. Déconnectez le nœud Event ActorBeginOverlap du nœud Door Control en maintenant enfoncé Alt et en cliquant sur le lien entre les deux nœuds. Déplacez le nœud Event vers l'arrière afin d'avoir de la place pour mettre plus de nœuds d'action avant le nœud Door Control.

   Déconnecter les nœuds de blueprint

3. Faites glisser la broche du nœud Event ActorBeginOverlap et ajoutez un nœud Set Other Actor. Connectez la broche Autre acteur du nœud Event à la broche Autre acteur du nœud Set.

   

   Elle stocke l'acteur qui a chevauché la zone de la porte.

4. Depuis le nœud Set Other Actor, faites glisser la broche bleue Valeur et créez un nœud Does Object Implement Interface. Définissez la valeur de Interface sur BPI_PlayerKeys.

   

5. Faites glisser la broche Exec du nœud Set Other Actor et créez un nouveau nœud Branch. 

Pour vérifier si la porte utilise des clés, procédez comme suit :

1. Faites glisser la broche True du nœud Branch et créez un nœud Fn Has Key, qui est la fonction que vous avez créée précédemment dans ce tutoriel. Il prend le type de clé nécessaire pour ouvrir la porte et vérifie la matrice Clés détenues du joueur pour ce type de clé. L'appel de cette fonction ici permet d'exécuter les nœuds qu'elle contient. 

2. Faites glisser la broche Exec du nœud Fn Has Key et créez un nouveau nœud Branch. 

3. Connectez la broche Clé trouvée du nœud Fn Has Key à la broche Condition du nœud Branch.

4. Connectez la broche True du nouveau nœud Branch à la broche Jouer du nœud Door Control.

   

Pour l'instant, cette logique ne permet à la porte de s'ouvrir que lorsque le joueur dispose de la bonne clé. La porte doit aussi s'ouvrir quand :

• La porte n'a pas besoin de clés, ou

• Un personnage non joueur essaie de passer par la porte.

Le premier nœud Branch et le nœud And testent ces deux conditions. Si l'un des deux est false, le nœud Branch est également false. 

Pour vous assurer que la porte s'ouvre pour les PNJ et lorsque les clés ne sont pas nécessaires, procédez comme suit :

1. Connectez la broche False du premier nœud Branch directement à la broche Jouer du nœud Door Control. Vous pouvez utiliser des connecteurs en double-cliquant sur un lien entre deux nœuds pour organiser votre blueprint.

   

2. Compilez et enregistrez le blueprint.

Lorsque l'acteur n'implémente pas l'interface de la clé ou que la porte ne nécessite pas de clés (UseKeys = False), la porte s'ouvre quand même.

La nouvelle logique du graphique d'événements BP_DoorFrame devrait ressembler à ceci :

Ajouter des commentaires à un blueprint

Vous pouvez ajouter des blocs de commentaires dans vos blueprints pour créer des notes uniquement visuelles qui regroupent des nœuds et expliquent le fonctionnement de chaque partie du blueprint. Les commentaires vous aident, vous et les membres de votre équipe, à comprendre en un coup d'œil la fonctionnalité des nœuds et à maintenir vos blueprints organisés.

Lors de la construction d'une logique de blueprint, concentrez-vous d'abord sur la création de la fonctionnalité, puis mettez en évidence les nœuds que vous avez ajoutés et ajoutez un commentaire pour les contenir et les décrire.

Pour ajouter un commentaire dans un blueprint, procédez comme suit :

1. Cliquez sur le graphique pour vous assurer qu'il s'agit du panneau actif.

2. Appuyez sur la touche C de votre clavier. Cela ajoute un champ de commentaire.

3. Double-cliquez sur le champ de texte en haut de la zone pour saisir un commentaire.

4. Pour redimensionner le bloc de commentaire, assurez-vous qu'il est sélectionné (surligné par un contour jaune), puis faites glisser une arête ou un coin.

5. Pour regrouper des notes dans un commentaire, faites glisser ces nœuds dans les limites du commentaire.

Vous pouvez également sélectionner un ou plusieurs nœuds et appuyer sur C pour ajouter un commentaire contenant les nœuds sélectionnés. 

Tester vos portes

Revenez à votre niveau dans l'éditeur de niveau. Utilisez la propriété Clé requise de vos portes pour les configurer avec des couleurs différentes et ajouter un BP_Key pour chaque couleur.

Maintenant, jouez au jeu. Si vous vous approchez de la porte sans avoir ramassé de clé, la porte ne s'ouvrira pas.

Cependant, si vous ramassez la clé, la porte s'ouvre lorsque vous vous en approchez. Elle se ferme automatiquement lorsque vous vous en éloignez suffisamment. 

Après avoir ramassé une clé colorée, essayez d'ouvrir une porte de couleur différente. La porte doit rester fermée.

Si vous travaillez sur l'exemple de niveau de ce tutoriel, sélectionnez la porte qui mène au couloir 2 et remplacez la clé requise par la clé bleue. Ensuite, sélectionnez la porte qui mène au couloir 3 et remplacez la clé requise par la clé rouge. Attribuez la couleur jaune à la porte du couloir 1.

Ajouter des commentaires avec des messages de débogage

Si vous souhaitez vérifier ce qui se passe dans un blueprint pendant le jeu, vous pouvez utiliser des nœuds Print String pour afficher des messages à l'écran. L'Unreal Engine n'affiche pas ces messages dans le jeu final.

Essayez d'ajouter un nœud Print String pour confirmer le type de clé que le joueur a ramassé.

Pour afficher un message de débogage avec des nœuds Print String, procédez comme suit :

1. Dans le graphique d'événements BP_AdventureCharacter, accédez à l'ensemble de nœuds qui commence par Event fnBPIAddKey et ajoutez des clés à la matrice HeldKeys.

2. Faites glisser la broche Exec du nœud Add et ajoutez un nœud Print String.

3. In string (Dans la chaîne) est le texte qui apparaît à l'écran. Saisissez un texte personnalisé ou connectez la broche Type de clé du nœud Event à In String. Cela permet d'afficher la clé que le joueur ramasse.

   

4. Compilez le blueprint.

5. Jouez à nouveau à votre jeu et ramassez les clés. Un texte de débogage confirmera chaque couleur de clé lorsque vous les ramassez. 

6. Une fois que vous avez terminé, retournez dans le graphe de nœud et supprimez les nœuds Print String et Enum to String. Compilez et enregistrez le blueprint.

Si un élément ne fonctionne pas comme prévu dans un blueprint, vous pouvez ajouter des nœuds Print String après les calculs, les appels d'événement ou les appels de fonction, afin de suivre ce qui se passe au niveau des valeurs et du flux.

Placer les objets à ramasser

Jusqu'ici, vous avez placé des clés sur le sol. Pour rendre le jeu plus intéressant et stimulant pour le joueur, essayez d'ajouter un élément de plateforme. 

Dans l'exemple de niveau de ce tutoriel, nous avons ajouté de la verticalité en plaçant la clé en hauteur, obligeant ainsi le joueur à sauter pour l'atteindre. Ici, il existe un léger risque de chute, obligeant à recommencer.

Le joueur s'entraîne à sauter sur la première et la deuxième plateforme avant d'être mis à l'épreuve avec le saut final, plus difficile, vers le pilier.

Essayez l'exemple de niveau

Si vous souhaitez ajouter les nouveaux éléments de la salle conçus dans cette partie de la série de tutoriels au lieu de créer les vôtres, copiez les extraits ci-dessous.

L'ébauche de la salle de départ

Cet extrait de texte contient la rampe, le sol en retrait, la colonne et deux maillages de plateforme ajoutés pour créer le chemin vers la clé jaune.

Begin Map
   Begin Level
      Begin Actor Class=/Script/Engine.StaticMeshActor Name=Floor_168 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168'"
         Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
         End Object
         Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
            StaticMesh="/Script/Engine.StaticMesh'/Engine/MapTemplates/SM_Template_Map_Floor.SM_Template_Map_Floor'"
            bUseDefaultCollision=False
            StaticMeshDerivedDataKey="STATICMESH_34081786561B425A9523C94540EA599D_359a029847e84730ba516769d0f19427Simplygon_5_5_2156_18f808c3cf724e5a994f57de5c83cc4b_680318F3495BDBDEBE4C11B39CD497CE000000000100000001000000000000000000803F0000803F00000000000000000000344203030300000000"
            MaterialStreamingRelativeBoxes(0)=4294901760

Pour créer les formes d'ébauche de la salle de départ, procédez comme suit :

• Dans l'Unreal Editor, supprimez toutes les clés de la salle de départ afin qu'elles ne se perdent pas dans la nouvelle géométrie.

• Cliquez sur Copier l'extrait complet.

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

  Si vous avez déplacé l'une des salles de l'ébauche depuis la partie précédente de ce tutoriel, les nouveaux maillages peuvent ne pas apparaître au bon endroit. Déplacez-les selon vos besoins.

• Trois dalles de sol recouvrent le nouveau sol en retrait. Dans le hublot, cliquez sur chacun d'eux et appuyez sur Suppr.

  

Suivant

Votre personnage peut ramasser des clés, mais aucun retour ne l'informe sur celles qu'il a déjà récupérées. Dans la prochaine section, vous allez créer un affichage tête haute (ATH) pour le joueur, qui affiche les clés dans son inventaire.

• 

  ATH de joueur

  Créez un affichage tête haute (ATH) simple qui se met à jour lorsque le joueur ramasse un objet.