Créer une clé

Dans cette section, vous allez créer votre premier objet de jeu : un blueprint de clé.

Pour créer la fonctionnalité des objets de jeu dans votre niveau, vous utiliserez le système de programmation visuelle Blueprint. Dans l'Unreal Engine, les blueprints sont des ressources possédant une représentation physique et une fonctionnalité spéciale, comme la possibilité pour le joueur de les ramasser.

Vous pouvez utiliser le système de programmation visuelle Blueprint pour créer les fonctionnalités sans code via une interface basée sur les nœuds pour définir le comportement d'un objet de jeu.

Tout d'abord, définissez l'acteur en jeu de la clé, en ajoutant des composants permettant de configurer les clés pour qu'elles apparaissent sous trois variations différentes : un ovale jaune, un rectangle bleu ou un cône rouge. Au lieu de créer des ressources distinctes pour chaque variation, les blueprints permettent de créer toutes ces options en une seule ressource.

Ajoutez ensuite le comportement de la clé, c'est-à-dire la capacité du personnage joueur de la ramasser. Le ramassage d'objets est l'une des mécaniques de jeu les plus courantes.

Voici un aperçu de toutes les ressources que vous allez créer pour concevoir une clé avec trois options d'apparence différentes et permettre à un personnage joueur de ramasser la clé :

Avant de commencer

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

• L'IU de l'Unreal Editor, notamment le navigateur de contenu et le hublot.

• Les fondamentaux du système Blueprint. Pour plus d'informations, consultez la documentation sur les principes de base de Blueprint.

Vous aurez besoin des ressources suivantes de la Configuration du projet et ébauche de niveau :

• Un niveau avec des salles bloquées.

Définir les types de clé et les attributs de clé

Avant de créer le blueprint de clé, vous devrez définir les données de clé que le blueprint utilisera pour créer les variations rouge, jaune et bleue.

Pour représenter les différents types de clés utilisés dans votre jeu, utilisez une énumération et une structure.

Chaque énumérateur agit comme une étiquette sur un conteneur et la structure est comme le contenu de chaque conteneur.

Définir les types de clé dans une enum

Commencez par créer une ressource d'énumération qui définit vos variantes de clé : rouge, jaune et bleu.  

Pour créer une ressource d'enum, procédez comme suit :

1. Ouvrez le navigateur de contenu, ou un tiroir à contenu, en utilisant le bouton du tiroir à contenu dans le coin inférieur gauche de l'Unreal Engine.

2. Créez un espace de stockage pour les blueprints et les ressources associées que vous allez créer dans ce tutoriel. Accédez au dossier Contenu > AdventureGame > Concepteur. Faites un clic droit dans ce dossier, puis cliquez sur Nouveau dossier.

3. Nommez le nouveau dossier Blueprints.

4. Dans le dossier Blueprints, créez un autre dossier nommé Core.

5. Faites un clic droit dans le dossier Core, accédez à Blueprints, et cliquez sur Énumeration dans le menu Créer une ressource. Nommez la nouvelle ressource Enum_KeyType.

   

6. Double-cliquez sur la ressource pour l'ouvrir dans une nouvelle fenêtre.

L'énumération contient une liste d'options d'énumérateur. 

Pour ajouter des types de clés à l'enum, procédez comme suit :

1. Cliquez trois fois sur le bouton Ajouter un énumérateur pour ajouter trois nouvelles énumérations à la liste.

2. Remplacez le Nom d'affichage du premier énumérateur par Bleu. Remplacez celui du deuxième énumérateur par Jaune et du troisième par Rouge.

   

3. Enregistrez le fichier de ressource d'enum en cliquant sur le bouton Enregistrer dans le coin supérieur gauche de la fenêtre. Vous pouvez également utiliser le raccourci CTRL+S. 

Lorsque vous ajoutez un énumérateur, vous ajoutez en réalité une option à la liste. Les valeurs que vous utiliserez pour distinguer les différents types de clé seront les suivantes : bleu, jaune et rouge.

Contrairement aux blueprints, vous n'avez pas à compiler les ressources de données puisque vous ne compilez aucune fonctionnalité. 

Définir les attributs de clé dans une structure

Créez ensuite une structure qui définit les attributs qui distinguent chaque type de clé : une forme de maillage et une couleur.

Pour créer une ressource de structure (struct), procédez comme suit :

1. Revenez au navigateur de contenu et assurez-vous que vous êtes toujours dans le dossier Contenu > AdventureGame > Concepteur > Core.

2. Faites un clic droit n'importe où dans le dossier Core, accédez à Blueprints, et cliquez sur Structure. Nommez cette ressource Struct_KeyData.

   

3. Double-cliquez sur la nouvelle ressource pour l'ouvrir dans une nouvelle fenêtre avec les propriétés de la structure.

4. La structure aura une variable par défaut appelée MemberVar_0. Cliquez sur Ajouter une variable pour ajouter une deuxième variable.

5. Changez le nom de la première variable en Matériau de clé et celui de la deuxième variable en Maillage de clé.

6. Un type de données est assigné à chaque variable. Il est défini sur Booléen (une valeur true ou false) par défaut. Vous devez modifier le type des deux variables.

   En ce qui concerne la variable Matériau de clé, cliquez sur le menu déroulant Booléen. Saisissez instance de matériau dans le champ de recherche, survolez l'option Instance de matériau et sélectionnez Référence d'objet. 

   

7. Répétez ces étapes pour modifier le type de variable de Maillage de clé en Maillage statique > Référence d'objet. 

   

8. Enregistrer le fichier de ressource de structure. 

Vous avez maintenant créé deux attributs que chaque type de clé utilisera : un matériau de clé qui définira la couleur de la clé et un maillage de clé qui définira la forme de la clé. 

Vous avez fini de définir le type de données que doit contenir la clé. Configurez ensuite les couleurs des clés, puis créez chaque type de clé.

Créer des couleurs de clé 

Maintenant que vous disposez des données pour les types de clé bleu, jaune et rouge, créez des matériaux avec des couleurs correspondantes que vous assignerez à chaque type de clé.

Dans l'Unreal Engine, un matériau définit l'apparence d'une surface. Il contrôle des éléments comme la couleur, la texture, la brillance, la transparence et bien d'autres. Une instance de matériau est une copie d'un matériau qui utilise le matériau comme base, mais qui peut remplacer des paramètres spécifiques comme les couleurs ou les textures, sans avoir à créer un tout nouveau matériau à partir de zéro.

Dans cet exemple, vous créerez un matériau de base qui définira les attributs de toutes les clés du jeu. Vous créerez ensuite deux instances de matériau de ce matériau pour copier tous les attributs, mais en remplaçant les couleurs.

Pour créer une ressource de matériau colorée, procédez comme suit :

1. Accédez au navigateur de contenu. Accédez au dossier Contenu > AdventureGame > Concepteur.

2. Faites un clic droit sur le dossier Concepteur et cliquez sur Nouveau dossier. Nommez ce dossier Matériaux.

3. Accédez au dossier Matériaux. Faites un clic droit sur le dossier et sélectionnez Matériau pour créer une ressource de matériau.

   

4. Changez le nom de la ressource de matériau en M_BasicColor.

   L'exemple de niveau du tutoriel utilise le préfixe M_ comme convention d'affectation de noms pour identifier les matériaux.

5. Double-cliquez sur le matériau pour l'ouvrir. Cela ouvrira l'éditeur de matériau dans une nouvelle fenêtre.

L'éditeur de matériau est un éditeur qui repose sur les nœuds, ce qui signifie qu'il présente certaines similitudes avec le système de programmation visuelle Blueprint. Vous devriez voir un nœud appelé M_BasicColor. Il s'agit du nœud principal que vous pouvez utiliser pour modifier les propriétés de ce matériau.

La propriété Couleur de base définit la couleur de ce matériau. Vous pouvez cliquer sur l'échantillon de couleur grise à côté de Couleur de base pour définir manuellement la couleur. 

Au lieu d'utiliser la pipette, créez un nœud de paramètre Color que vous pourrez remplacer dans chaque instance de matériau. Ainsi, vous créerez un matériau auquel vous pouvez donner plusieurs couleurs. Créer un paramètre revient à ajouter une variable. Cela transforme la couleur du matériau en paramètre modifiable dans une instance de matériau.

Pour créer un nœud de paramètre Color, procédez comme suit :

1. À côté de Couleur de base, vous verrez une broche. Cliquez sur la broche et faites-la glisser vers une zone vide du graphique. 

   

2. Dans la liste déroulante, saisissez VectorParameter dans le champ de recherche et sélectionnez VectorParameter.

   Cela crée un nouveau nœud avec une pipette. Une variable de type vecteur possède trois valeurs. Vous pouvez donc les utiliser pour définir les valeurs RVB d'une couleur.

3. Le nom par défaut du nœud, Param, est mis en lumière d'accentuation lorsque vous créez le nœud. Renommez le nœud Color pour l'identifier plus facilement dans vos instances de matériau.

   Si Param n'est pas en lumière d'accentuation, cliquez sur le nœud, puis sur le nom du nœud pour le renommer.

4. Sur le nouveau nœud Color, cliquez sur le carré en damier à côté de Valeur par défaut pour ouvrir une pipette.

   

5. Dans le champ sRVB Hex, changez la valeur pour F7DE0000 (une couleur jaune) et cliquez sur OK. 

   

6. Enregistrez et fermez la ressource de matériau.

Créez ensuite des instances de matériau pour ajouter plus de couleurs sans avoir à recréer le matériau principal. 

Pour créer trois instances de matériau pour vos couleurs de clé, procédez comme suit :

1. Dans le navigateur de contenu, faites un clic droit sur la ressource M_BasicColor que vous avez créée. En haut du menu contextuel, cliquez sur Create Material Instance.

2. Nommez la ressource d'instance de matériau M_BasicColor_Red. Double-cliquez sur la ressource pour l'ouvrir.

   

   Vous remarquerez que cette fenêtre est différente de l'éditeur de matériau. C'est parce qu'une instance de matériau ne nécessite pas toute la suite d'édition d'un matériau. Elle se concentre plutôt sur la modification des paramètres que vous avez définis dans le matériau de base.

3. Dans le panneau Détails, sous les groupes de paramètres en haut, développez Valeurs de paramètre de vecteur global.

   

4. Vous verrez un paramètre Couleur désactivé, qui correspond au nœud VectorParameter que vous avez ajouté au matériau de base. Cliquez sur la case près de Couleur pour l'activer et le remplacer.

   

5. Cliquez sur l'échantillon de couleur à côté de Color et réglez la valeur de sRVB Hex sur F7005A00. L'instance de matériau adopte alors une jolie couleur rouge vif !

6. À vous de jouer ! Répétez ce processus pour créer deux instances de matériau supplémentaires : 

   1. Créez une instance de matériau nommée M_BasicColor_Blue. Remplacez le paramètre Couleur par sRVB Hex = 00AF700 et enregistrez la ressource. 

   2. Créez une instance de matériau nommée M_BasicColor_Yellow. Conservez la couleur du matériau de base et enregistrez la ressource.  

Créer le blueprint de clé

Maintenant que vous disposez de toutes les pièces nécessaires, il est temps de créer le blueprint de clé. Le blueprint de clé est la ressource que vous pouvez ajouter à un niveau pour en créer un acteur instancié, doté de la fonctionnalité permettant au joueur de la ramasser.

Pour créer une nouvelle classe de blueprint pour votre clé, procédez comme suit :

1. Accédez au navigateur de contenu et accédez au dossier Contenu > AdventureGame > Concepteur > Blueprints.

2. Créez un dossier appelé Clé.

3. Accédez au dossier Clé. Faites un clic droit dans le dossier et sélectionnez Classe de blueprint.

4. Sélectionnez Acteur comme classe parente.

   

5. Nommez ce nouvel acteur BP_Key et double-cliquez dessus pour l'ouvrir.

   L'exemple de niveau du tutoriel utilise le préfixe BP_ comme convention d'affectation de noms pour identifier les classes de blueprint.

La classe parente Acteur est généralement utilisée pour les objets pouvant être placés dans un niveau. Elle n'intègre pas de fonctionnalités supplémentaires, comme le mouvement, à l'instar de la classe parente Personnage, mais elle peut être utilisée pour créer des interactions et une logique.

Vous devez ajouter quelques éléments à notre blueprint de clé pour qu'il fonctionne correctement :

1. Un maillage statique qui représente visuellement la clé dans votre projet.

2. Un volume de collision qui détecte quand le joueur est suffisamment proche pour ramasser la clé.

3. Un moyen de savoir de quel type de clé il s'agit.

4. Une logique de jeu pour déterminer ce qui se passe lorsque le joueur touche la clé.

Configurer les composants de la clé 

Tout d'abord, configurez les composants de la clé afin d'avoir un objet à placer et avec lequel interagir dans le monde du jeu.

Pour ajouter un composant de collision et une forme de maillage à la clé, procédez comme suit :

1. Dans BP_Key, accédez à l'onglet Hublot.

2. Dans le panneau Composants, en haut à gauche, cliquez sur Ajouter, puis recherchez et sélectionnez Collision de capsule.

   

   Il s'agit du volume de collision que le joueur peut toucher pour ramasser la clé. Sans cela, le joueur ne pourrait pas détecter la clé. 

   Vous pouvez ajouter une collision au maillage de clé lui-même, mais utiliser une forme de collision permet d'égaliser la géométrie complexe, ce qui améliore la détection de collision et les performances du jeu. 

3. Sélectionnez le composant Capsule et cliquez à nouveau sur Ajouter. Cette fois-ci, recherchez et sélectionnez la forme de base Sphère et renommez-la KeyMesh. 

   En sélectionnant le composant Capsule, puis en ajoutant le maillage de sphère, le maillage devient un enfant de la capsule et la capsule est le parent du maillage. Le composant enfant hérite de toutes ses propriétés du parent. 

4. Configurez le composant KeyMesh :

   1. Sélectionnez le composant KeyMesh. Dans le panneau Détails, accédez à la catégorie Transformation. À côté de Échelle, définissez les valeurs sur 0,3, 0,3 et 1,0. 

      

      Les côtés du maillage sont rétrécis pour leur donner une forme ovale.

   2. Sous la catégorie Collision, définissez Préréglages de collision sur NoCollision.

      

      Vous avez ajouté une collision avec le composant Capsule, ce qui désactive la collision sur le maillage, garantissant que le personnage joueur peut ramasser la clé sans rebondir sur le maillage statique.

5. Configurez le composant Capsule :

   • Sélectionnez le composant Capsule. Dans le panneau Détails, sous la catégorie Transformation, définissez Emplacement sur 0,0, 0,0, 80,0.

     La clé flotte alors au-dessus du sol. Le maillage se déplace avec la capsule, car le maillage est un composant enfant qui hérite de toutes les propriétés du composant parent.

   • Dans la catégorie Forme, définissez la demi-hauteur de la capsule sur 60,0. Cela étire le volume de collision pour mieux entourer le maillage.  

6. Dans le panneau Composants, sélectionnez DefaultSceneRoot. Cliquez sur Ajouter et sélectionnez Mouvement rotatif. Cela fait pivoter lentement la clé pour la rendre plus intéressante pour le joueur.

   

7. Enregistrez et compilez le blueprint.

Configurer les propriétés de la clé

Votre clé doit également stocker des informations, comme le type de clé et les matériaux et maillages correspondant à chaque type de clé. 

Pour définir cela, utilisez l'enum de type de clé et la structure de données de clé que vous avez créées. 

Pour ajouter une variable de type de clé au blueprint, procédez comme suit :

1. Sous le panneau Composants, vous verrez le panneau My Blueprint. Dans la section Variables, cliquez sur le bouton plus (+) pour ajouter une nouvelle variable.

2. Nommez la variable KeyType.

3. Par défaut, son type est booléen. Cliquez sur le menu déroulant du type, recherchez Type de clé d'enum et sélectionnez-le. Ce type de variable correspond à l'enum que vous avez créée. Il est donc temps de l'utiliser ! Ici, cela signifie que la variable KeyType peut être définie sur Rouge, Jaune ou Bleue.

   Dans les blueprints, le type de variable est également appelé type de broche, car les variables apparaissent comme des broches dans les nœuds.

4. Cliquez sur l'œil à côté de la variable KeyType pour en faire une variable publique et modifiable. C'est important de le faire afin de pouvoir modifier la valeur de cette variable dans l'Unreal Editor ultérieurement et définir le type de chaque clé dans votre niveau.

   

5. Cliquez sur KeyType pour le sélectionner. Dans le panneau Détails, à côté de la propriété Catégorie, supprimez Par défaut et tapez Configuration.

   La propriété KeyType apparaît alors dans le panneau Détails, sous une catégorie appelée Configuration.

   

Chaque type de clé doit avoir une combinaison de forme et de couleur. Dans l'étape suivante, vous allez créer une variable Mappage pour définir ces combinaisons.

Pour configurer une variable qui associe les types de clés à des formes et des couleurs, procédez comme suit :

1. Dans le panneau My Blueprint, ajoutez une nouvelle variable appelée KeyMap, également de type Type de clé d'enum.

2. Une fois la variable KeyMap sélectionnée, dans le panneau Détails, à côté du menu déroulant Type, un autre menu permet de définir le type de conteneur de la variable ou le nombre de valeurs contenues dans la variable. Changez le type de conteneur sur Mappage.

   

3. Lorsque vous configurez le conteneur Mappage, un autre menu déroulant Type apparaît à côté du type de conteneur. Il s'agit du type de données stockées dans chaque option de mappage. Vous avez déjà défini ces données de clé dans une structure, vous pouvez donc cliquer sur le menu déroulant et définir le type de données sur Struct_KeyData.

4. Compilez le blueprint de manière à pouvoir remplir le KeyMap avec des matériaux et des formes de maillage, en configurant une paire matériau-maillage pour chaque option de KeyType.

5. Dans le panneau Détails, accédez à la catégorie Valeur par défaut.

6. En regard de Mappage de clé, cliquez sur le bouton + pour ajouter un nouvel élément au mappage.

7. Changez le Type de clé de Bleu à une couleur différente. Si vous ne le faites pas, il se peut que vous ne puissiez pas ajouter un nouvel élément, car un élément avec le type de clé par défaut existe déjà.

8. Répétez cette opération deux fois de plus pour créer les deuxième et troisième éléments.

9. Une fois les trois éléments de mappage ajoutés, configurez les types de clé avec les valeurs suivantes :

   Type de clé	Matériau de clé	Maillage de clé
   Rouge	M_BasicColor_Red	Cône
   Jaune	M_BasicColor_Yellow	Sphère
   Bleu	M_BasicColor_Blue	Cube

   Le projet contient plusieurs maillages nommés Cube et Sphère. Les maillages Cube et Sphère corrects doivent apparaître en deuxième position dans la liste lorsque vous les recherchez. Si vous les survolez, leur infobulle doit indiquer le chemin /Moteur/BasicShapes. 

   

   Votre KeyMap devrait maintenant ressembler à ceci : 

   

10. Enregistrez et compilez le blueprint. 

Enfin, vous avez besoin d'une variable qui stocke une référence au personnage joueur lorsqu'il touche la clé. 

Pour créer une variable qui stocke une référence à un autre acteur, procédez comme suit :

1. Dans la section Variables, ajoutez une nouvelle variable appelée OtherActor.

2. Changez son type en Acteur > Référence d'objet.

3. Dans le panneau Détails, définissez son Type de conteneur sur Unique, car vous n'avez besoin de faire référence qu'à un seul acteur qui interagit avec cette clé, à savoir le joueur.

Maintenant, les variables de la clé devraient ressembler à ce qui suit :

Tester la clé

Faites un test de la clé pour voir ce que cela donne. 

Revenez dans votre niveau et, dans le navigateur de contenu, faites glisser BP_Key dans votre niveau. Vous avez créé un blueprint dont vous pouvez ajouter des instances à votre jeu. Cependant, il est encore gris.

Une fois la clé sélectionnée, accédez au panneau Détails. Recherchez la catégorie Configuration que vous avez créée, puis la propriété Type de clé. Elle peut être modifiée de Bleu à Jaune, puis à Rouge, mais cela n'affecte pas la clé ovale grise pour l'instant. 

C'est parce que vous avez ajouté des composants et des données à votre clé, mais que ces éléments ne communiquent pas encore entre eux. C'est là qu'intervient le système de programmation visuelle Blueprint. Vous construirez une logique (nœuds et liens) pour transmettre des informations autour d'un blueprint et effectuer des actions avec ces informations.

Définir les valeurs de clé avec une fonction de blueprint

Créez ensuite une fonction qui relie les options de KeyMap au composant KeyMesh. Celle-ci définit automatiquement la forme de maillage et la couleur de matériau correctes pour une clé en fonction de son type.

Au lieu de créer la fonction dans le blueprint de clé, placez-la dans une nouvelle bibliothèque de fonctions de blueprint, qui est un type de ressource de blueprint qui stocke une collection de fonctions réutilisables. Ces fonctions ne sont pas liées à un blueprint ou à un acteur spécifique. Elles sont plutôt accessibles dans l'ensemble de votre projet. Les bibliothèques conservent les fonctions utiles au même endroit, ce qui vous évite d'avoir à les copier-coller dans plusieurs blueprints.

Pour créer une bibliothèque de fonctions de blueprint avec une nouvelle fonction, procédez comme suit :

1. Accédez au navigateur de contenu et atteignez Contenu > AdventureGame > Concepteur > Core.

2. Faites un clic droit dans le dossier Core, accédez à Blueprint, et sélectionnez Bibliothèque de fonctions de blueprint. Nommez la nouvelle ressource BPL_FPGame et ouvrez-la.

   

3. Dans le panneau My Blueprint, dans la section Fonctions, vous commencez par une nouvelle fonction qui est mise en lumière d'accentuation. Nommez-la fnBPLSetKey.

   

   L'exemple de projet du tutoriel utilise une étiquette BPL pour les fonctions d'une bibliothèque de blueprints et le préfixe fn pour les fonctions. Cela permet d'identifier ce qu'est SetKey et d'où il vient, et de trouver plus facilement la fonction dans la liste des actions du nœud.

Ensuite, configurez la fonction avec les entrées et les sorties nécessaires. 

Les entrées sont les valeurs que vous transmettez à une fonction pour qu'elle puisse jouer son rôle. Elles jouent un rôle similaire à celui des variables. La fonction fnBPLSetKey doit effectuer des actions entre les propriétés KeyType, KeyMap et KeyMesh. Elles doivent donc être des entrées.

Les sorties sont les informations que la fonction renvoie au blueprint, généralement après avoir créé un résultat. La fonction fnBPLSetKey n'a pas besoin de sorties. 

Pour ajouter des entrées à la fonction fnBPLSetKey, procédez comme suit :

1. Cliquez sur la fonction fnBPLSetKey pour la sélectionner. Dans le panneau Détails, en regard de la catégorie Entrées, cliquez sur le bouton + pour créer une nouvelle entrée.

   À l'instar des variables, chaque entrée a un nom, un type de broche de variable et un type de conteneur.

2. Changez le nom de l'entrée en Matrice de maillages statiques.

3. Changez son type en Composant de maillage statique > Référence d'objet. Dans le graphique de nœud de la fonction, vous constaterez que le nœud d'entrée de la fonction violette comporte désormais une broche avec l'entrée que vous avez créée et que le style de la broche reflète le type (matrice de maillages statiques).

4. Cliquez sur le menu déroulant Type de conteneur à côté du type, et sélectionnez Matrice.

   

   Une matrice est une variable qui stocke plusieurs valeurs du même type dans un seul conteneur. Chaque valeur est stockée en tant qu'élément de matrice.

5. Configurez une autre entrée correspondant à la propriété KeyMap de la clé :

   1. Ajoutez une autre entrée et nommez-la KeyMap.

   2. Cliquez sur le menu déroulant Type de broche et définissez-le sur Type de clé d'enum.

   3. Cliquez sur le menu déroulant Type de conteneur et sélectionnez Mappage.

   4. Cliquez sur le menu déroulant Type de valeur et définissez-le sur Données de clé de structure.

6. Configurez une entrée de type de clé :

   1. Ajoutez une autre entrée nommée Clé.

   2. Définissez son conteneur sur Unique et conservez son type sur Type de clé d'enum.

Vos trois entrées devraient ressembler à ceci :

Vous pouvez maintenant construire les nœuds de la fonction. Dans le panneau graphique, vous pouvez voir le nœud d'entrée de fonction fnBPLSetKey avec les entrées que vous venez de créer : une matrice de maillages statiques, un mappage de clé et une clé.

Pour ajouter une logique à la fonction qui configure les clés avec une nouvelle forme de maillage de clé, procédez comme suit :

1. Faites glisser la broche d'exécution (exec) du triangle de ce nœud, recherchez Pour chaque boucle et sélectionnez-le dans la liste des actions de nœud. Cela crée un nouveau nœud connecté au nœud fnBPLSetKey.

   Avec le nœud For Each Loop, vous pouvez réaliser des actions sur chaque élément d'une matrice. Toute logique que vous connectez à la broche d'exécution Corps de la boucle s'exécute une fois par élément de matrice. Une fois la boucle terminée, l'exécution passe par la broche Terminé.

   

2. Faites glisser la broche Matrice de maillages statiques du nœud fnBPLSetKey et reliez-la à la broche Matrice du nœud For Each Loop.

   

   La clé n'a qu'un maillage, mais fnBPLSetKey utilise une matrice de maillages statiques qui peut donc être utilisée avec divers objets de niveau. Par exemple, dans la prochaine partie de cette série de tutoriels, vous utiliserez le blueprint de porte, qui comporte deux maillages statiques pour la porte droite et la porte gauche.

3. Ensuite, faites glisser la broche Mappage de clé du nœud fnBPLSetKey, puis recherchez et sélectionnez un nœud Find. Ce nœud peut prendre un type de clé et extraire le maillage et le matériau correspondants de KeyMap.

4. Faites un clic droit sur la broche de sortie bleue du nœud Find, et cliquez sur Scinder la broche de structure. 

   

   Cela scinde la sortie en Matériau de clé et Maillage de clé, qui sont les deux variables de Struct_KeyData.

5. Connectez la broche Clé du nœud fnBPLSetKey à la broche turquoise Clé du nœud Find. 

   

6. À présent, sur le nœud For Each Loop, faites glisser la broche Corps de la boucle et recherchez Is Valid dans la catégorie Struct. Ajoutez le nœud Is Valid avec une icône en forme de point d'interrogation (?) à côté, car c'est celui que vous utilisez pour les valeurs de structure. 

   

   Ce nœud vérifie si une forme de maillage valide a été transmise à la fonction. Le cas échéant, définissez le maillage statique de l'objet et son matériau. Sinon, définissez uniquement le matériau. 

7. Connectez la broche Maillage de clé du nœud Find à la broche Objet d'entrée du nœud Is Valid. 

   

8. Dans le nœud Is Valid, faites glisser la broche Is Valid et basculez l'option Sensible au contexte sur false.

   

9. Recherchez et ajoutez un nœud Set Static Mesh.

10. Faites glisser la broche Élément de matrice du nœud For Each Loop et connectez-la à la broche Cible du nœud Set Static Mesh.

    La broche Cible est l'entité sur laquelle le nœud agira. Vous voulez exécuter l'action Définir le maillage statique sur le KeyMesh, donc la matrice de maillages statiques doit être la cible.

11. Faites glisser la broche Maillage de clé du nœud Find et connectez-la à la broche Nouveau maillage du nœud Set Static Mesh. 

Le graphique de la fonction devrait maintenant ressembler à ceci :

Vous pouvez double-cliquer sur LE lien entre deux nœuds pour créer un connecteur supplémentaire. Survolez le connecteur jusqu'à ce que votre curseur se transforme en quatre flèches, puis faites glisser le connecteur pour redimensionner les liens. Elles peuvent vous aider à positionner librement vos nœuds et vos lignes.

Sélectionnez un lien et appuyez sur la touche Q pour le redresser.

Vous avez défini la forme du nouveau maillage sur la clé ; il ne vous reste plus qu'à définir le nouveau matériau.

Pour ajouter une logique qui configure les clés avec une nouvelle couleur de matériau de clé, procédez comme suit :

1. Faites glisser la broche Exec du nœud Set Static Mesh, puis recherchez le nœud Set Material (dans la catégorie Rendu > Material) et créez-le.

2. Faites glisser sa broche Cible jusqu'à la broche Élément de matrice du nœud For Each Loop.

3. Faites glisser sa broche Matériau jusqu'à la broche Matériau de clé du nœud Find.

   

4. Pour s'assurer que le matériau est défini lorsqu'aucun maillage n'est fourni, connectez la broche Is Not Valid du nœud à la broche d'exécution du nœud Set Material. Ajoutez deux connecteurs pour remodeler le lien.

5. Enregistrez et compilez le blueprint.

Votre fonction fnBPLSetKey complète devrait maintenant ressembler à ceci :

Initialiser les clés

Vous pouvez maintenant utiliser la fonctionnalité que vous avez créée dans le blueprint de clé. Tout d'abord, initialisez la clé en fonction du KeyType que vous lui assignez. 

Pour initialiser la clé, procédez comme suit :

1. Faites glisser la broche Exec du nœud Construction Script et recherchez la fonction fnBPLSetKey que vous avez créée.

   

   Le nœud fonctionnel nécessite une matrice de maillages statiques, un mappage de clé et une clé, que vous obtiendrez de BP_Key.

2. Dans le panneau My Blueprint, sous la section Variables, développez la catégorie Configuration et faites glisser la variable KeyType dans le graphe de nœud, près du nœud fonctionnel. 

   

3. Cela vous invite à indiquer si vous souhaitez obtenir (Get) ou définir (Set) la valeur de la variable. Dans ce cas, vous devez vérifier le type de clé, alors sélectionnez Get. 

4. Connectez la broche du nouveau nœud Get Key Type à la broche Clé du nœud Fn BPLSet Key.

   

5. Répétez le même processus pour la variable KeyMap. Faites-la glisser dans le graphe de nœud et créez un nœud Get. Connectez la broche de ce nœud à la broche KeyMap du nœud Fn BPLSet Key.

   

6. Ensuite, depuis le panneau Composants, faites glisser KeyMesh dans le graphique et créez un nœud Get. 

7. Le nœud Key Mesh contient une unique référence de composant de maillage statique, mais le nœud fonctionnel nécessite une matrice. L'Unreal Engine peut se charger de cette tâche pour vous : connectez la broche Maillage de clé à la broche Matrice de maillages statiques du nœud Fn BPLSet Key.

8. Enregistrez et compilez votre blueprint.

  Le script de construction de la clé devrait maintenant ressembler à ceci : 

Tester la fonctionnalité de la clé

Vous pouvez maintenant tester la fonctionnalité de changement de couleur que vous avez créée dans votre clé, ainsi que la nouvelle fonction. 

Fermez la fenêtre Éditeur de blueprint et retournez à l'éditeur de niveau.  

Puisque la valeur par défaut du type de clé est Bleue, votre clé doit être initialisée sous la forme d'un rectangle bleu. 

Sélectionnez l'acteur de clé et, dans le panneau Détails, sous la section Configuration, modifiez le paramètre Type de clé entre Jaune et Rouge. Lorsque vous modifiez cet élément, votre clé devrait changer de couleur et de forme dans le niveau !

Si vos clés rectangulaire et ovale apparaissent trop grandes, cela pourrait signifier que vous avez sélectionné des ressources de maillage inadéquates lors de la création de KeyMap. Retournez dans les détails de votre KeyMap et assurez-vous que les maillages Sphère et Cube proviennent du chemin /Moteur/BasicShapes.

Donner des clés au personnage joueur

Votre joueur doit pouvoir ramasser des clés et les autres objets doivent savoir quelles clés sont en possession du joueur. Pour gérer l'octroi et la récupération des clés, vous utiliserez une interface de blueprint.

Utilisez une interface de blueprint pour communiquer entre les blueprints 

Une interface de blueprint stocke une liste de fonctions qui peut être utilisée par chaque blueprint qui a accès à l'interface. Implémenter une interface implique de donner à votre blueprint la capacité de répondre à un ensemble partagé d'événements (ou de messages).

Dans un jeu dans lequel le joueur et les PNJ se déplacent, la clé a besoin d'un de s'assurer qu'elle n'interagisse qu'avec le personnage joueur. Pour ce faire, créez une interface de blueprint à implémenter dans BP_AdventureCharacter. Cela fait office d'autorisation que le blueprint du joueur utilise pour écouter le message de ramassage de clé. 

Les interfaces de blueprint sont utiles lorsque vous souhaitez que différents blueprints communiquent sans connaître leurs détails respectifs.

Pour créer une interface de blueprint avec deux fonctions, procédez comme suit :

1. Accédez au navigateur de contenu et accédez à Contenu > AdventureGame > Concepteur > Blueprints > Core.

2. Faites un clic droit dans le dossier Core, accédez à Blueprint, et créez une nouvelle interface de blueprint. Nommez cette ressource BPI_PlayerKeys et ouvrez-la en double-cliquant dessus.

   Cette fenêtre ressemble à celle de l'éditeur de blueprint. À droite se trouve le panneau My Blueprint qui répertorie toutes les fonctions de cette interface. En dessous se trouve le panneau Détails.

3. Dans le panneau My Blueprint se trouve déjà une fonction initiale conçue pour vous. Nommez-la fnBPIAddKey.

4. Sélectionnez la fonction puis, dans le panneau Détails, sous la section Entrées, cliquez sur le bouton + pour ajouter une nouvelle entrée.

5. Nommez l'entrée KeyType et réglez son type sur Type de clé d'enum.

   

6. Dans le panneau Détails, à côté de Catégorie, saisissez Clés. Votre fonction sera plus facile à trouver dans la liste d'interfaces des blueprints.

7. Ajoutez ensuite une nouvelle fonction au panneau My Blueprint appelée fnBPIGetKeys. Celle-ci gérera la récupération des clés. 

   

8. Sélectionnez la nouvelle fonction fnBPIGetKeys puis, dans le panneau Détails, sous la section Sorties, cliquez sur le bouton + pour ajouter un nouveau paramètre nommé Clés détenues. 

9. Définissez son type sur Type de clé d'enum et la valeur de retour sur Matrice afin qu'elle puisse indiquer les clés trouvées par le joueur. 

   

10. Enregistrez et compilez votre interface. Vous pouvez maintenant fermer la fenêtre BPI_PlayerKeys.

    Étant donné qu'une interface est liée au système de blueprint, vous devez la compiler comme avec les blueprints.

Notez que dans l'interface de blueprint, vous n'avez créé que des déclarations de fonctions. Les fonctions d'interface ne contiennent pas de logique, mais leur configuration détermine leur utilisation dans les blueprints. 

Les fonctions d'interface sans sortie (fnBPIAddKeys) agissent comme des événements tandis que les fonctions avec des sorties (fnBPIGetKeys) fonctionnent comme des fonctions normales auxquelles vous pouvez ajouter une logique.

Créer un nouveau personnage joueur

Avant d'ajouter le personnage, dupliquez un personnage joueur par défaut fourni dans le projet pour créer votre propre variante. Vous devez également modifier les paramètres du mode de jeu pour utiliser votre nouveau personnage.

Pour créer un personnage joueur à utiliser dans votre projet, procédez comme suit :

1. Accédez au navigateur de contenu et accédez au dossier Contenu > AdventureGame > Concepteur > Blueprints.

2. Créez un dossier nommé Personnages.

3. Accédez au dossier Contenu > Variant_Shooter > Blueprints > FirstPerson.

4. Faites glisser la ressource BP_ShooterCharacter dans le dossier Personnages que vous venez de créer, puis sélectionnez Copier ici.

5. Faites un clic droit sur la nouvelle copie dans le dossier Personnages pour la renommer BP_AdventureCharacter.

6. Accédez à Modifier > Paramètres du projet. Dans le panneau de gauche, accédez aux paramètres Projet > Mappages et modes.

7. Sous le paramètre DefaultGameMode, développez SelectedGameMode.

   Une ressource de mode de jeu qui définit un ensemble de règles pour le monde, y compris le personnage joueur par défaut. Vous devrez la modifier pour utiliser le nouveau personnage que vous avez créé. Vous pouvez modifier les paramètres du mode de jeu ici ou en ouvrant la ressource elle-même.

8. Changez la Default Pawn Class en BP_AdventureCharacter.

   

9. Fermez la fenêtre Paramètres du projet.

Pour modifier les paramètres du mode de jeu pour un niveau spécifique plutôt que pour l'ensemble de votre projet, utilisez les paramètres du monde. Cet onglet se trouve à côté du panneau Détails.  

Si le panneau Paramètres du monde n'est pas visible, dans la barre de menu principale, accédez à Fenêtre, puis sélectionnez Paramètres du monde. 

Ajouter l'interface de blueprint au joueur 

Dans cette section, vous allez modifier le blueprint du personnage joueur. Ce personnage dispose de nombreuses fonctions et interfaces pratiques déjà configurées. Vous allez donc ajouter l'interface BPI_PlayerKeys que vous avez créée précédemment pour lui permettre de ramasser les clés.

Modifiez ensuite le nouveau BP_AdventureCharacter pour utiliser les clés. 

Pour ajouter les fonctions d'interface de blueprint au personnage, procédez comme suit :

1. Atteignez le nouveau dossier Personnages et ouvrez BP_AdventureCharacter.

2. Ajoutez l'interface Clés de joueur BPI pour vous assurer que le blueprint du joueur l'implémente. Dans la barre d'outils située en haut de la nouvelle fenêtre, cliquez sur le bouton Paramètres de la classe.

3. Dans le panneau Détails à droite, dans la section Interfaces > Interfaces implémentées, cliquez sur Ajouter, puis sélectionnez BPI_PlayerKeys dans le menu déroulant. Cela permet à votre personnage d'implémenter les fonctions fnBPIGetKeys et fnBPIAddKey.

   

4. Compilez le blueprint pour pouvoir utiliser les fonctions d'interface. Dans la section Interfaces du panneau My Blueprint, vous verrez une catégorie Clés contenant les fonctions fnBPIAddKey et fnBPIGetKey. Elle comporte une icône jaune plutôt que grise, ce qui signifie que ces fonctions agissent comme des événements. 

Stocker les clés ramassées 

Le joueur doit stocker les clés qu'il a ramassées, alors créez une nouvelle variable pour cela. La variable doit contenir jusqu'à trois clés. Elle doit donc être une matrice.

Pour créer une variable de matrice permettant de stocker les clés du joueur, procédez comme suit :

1. Dans le blueprint BP_AdventureCharacter, ajoutez une nouvelle variable à la liste Variables du panneau My Blueprint.

2. Nommez la variable Clés détenues.

3. Sélectionnez la variable et, dans le panneau Détails, définissez le conteneur sur une matrice du type Type de clé d'enum. L'utilisation d'une matrice est importante, car le joueur peut avoir plusieurs clés à la fois en sa possession.

   

Pour ajouter des clés à la matrice Clés détenues lorsque le joueur ramasse une clé, procédez comme suit :

1. Ouvrez l'onglet Graphique d'événements du personnage.

2. Faites un clic droit sur le graphique et recherchez l'événement fnBPIAddKey. Il s'agit du nœud Event qui s'exécute à l'appel de la fonction fnBPIAddKey.

3. Faites glisser sa broche d'exécution, recherchez Array Add, puis sélectionnez un nœud Add. Ce nœud prend un nouvel élément et l'ajoute à une matrice.

4. Ajoutez une référence à la variable Clés détenues en la faisant glisser dans le graphique d'événements et en sélectionnant Get.

5. Connectez le nœud Held Keys à l'entrée Matrice cible du nœud Array Add. Cette broche ressemble à un carré.

6. Connectez la broche Type de clé du nœud Event à l'entrée Nouvel élément du nœud Add.

   

Maintenant, lorsque cette fonction d'événement est déclenchée, le personnage joueur ajoute la broche Type de clé fournie à sa matrice Clés détenues.

Récupérer la liste des clés du joueur

La porte sur laquelle vous travaillerez dans la prochaine partie de ce tutoriel doit vérifier toutes les clés du joueur. Ajoutez donc une fonctionnalité qui permet au joueur de renvoyer une matrice des clés qu'il a ramassées.

Pour gérer la récupération de clés, procédez comme suit :

1. Dans le blueprint BP_AdventureCharacter, sous My Blueprint > Interfaces, développez la section Clés.

   

    Dans la liste, l'icône de fnBPIGetKeys est grisée, ce qui signifie que vous pouvez l'utiliser comme une fonction ordinaire et pas simplement comme un événement.

2. Double-cliquez sur fnBPIGetKeys pour ouvrir le graphique de la fonction.

3. Ajoutez une référence à la variable Clés détenues en la faisant glisser et en sélectionnant Get.

4. Connectez le nœud Get Held Keys à la broche Clés détenues du nœud Return.

Le graphique fnBPIGetKeys devrait maintenant ressembler à ceci :

Amener les clés à détecter les collisions avec le joueur

Ajoutez ensuite une fonctionnalité qui déclenche la fonction d'événement fnBPIGetKeys lorsque le joueur ramasse une clé. Cela doit se produire lorsque le joueur touche le volume de collision de la clé. 

Ajoutez un événement qui appartient au composant de collision Capsule. Un événement se déclenche lorsque quelque chose se produit pendant le jeu. Dans le cas présent, lorsque l'acteur du joueur chevauche la capsule de la clé, celle-ci doit effectuer des actions.

Pour ajouter un événement de chevauchement et vérifier si l'acteur en chevauchement est le joueur, procédez comme suit :

1. Ouvrez votre blueprint BP_Key et atteignez une zone vide du EventGraph.

2. Dans le panneau Composants, faites un clic droit sur le composant Capsule et sélectionnez Ajouter un événement > Ajouter OnComponentBeginOverlap. Le nœud associé apparaît dans votre graphique d'événement. Ce nœud Event se déclenche en cas de chevauchement entre cet acteur et un autre.

   

   Le nœud Event fournit des informations sur cet événement. Par exemple, l'acteur en chevauchement qui a déclenché l'événement est transmis via la broche Autre acteur.

3. Faites glisser votre variable OtherActor de la liste Variables dans le graphique et sélectionnez Set. Un nœud Set enregistre une nouvelle valeur dans cette variable.

4. Faites glisser la broche Exec du nœud Event OnComponentBeginOverlap et connectez-la à l'entrée Exec du nœud Set Other Actor. 

5. Faites glisser la broche Autre acteur du nœud Event OnComponentBeginOverlap et connectez-la à l'entrée Autre acteur du nœud Set Other Actor.

   

6. Avant de faire quoi que ce soit avec la clé, vérifiez si l'acteur chevauchant est le joueur, puisqu'il s'agit du seul personnage capable de récupérer des clés. Vous savez qu'il s'agit du joueur s'il dispose de l'interface de blueprint.

   Faites un clic droit près du nœud Set et ajoutez un nœud Does Object Implement Interface.

7. Sur le nœud Does Object Implement Interface, définissez la broche Interface sur BPI_PlayerKeys.

8. Connectez la broche d'entrée Objet de test à la broche bleue du nœud Set Other Actor. Cette broche fonctionne comme un nœud Get Other Actor.

9. Sur le nœud Does Object Implement Interface, faites glisser la broche Valeur de retour et ajoutez un nœud Branch. 

10. Connectez la broche d'entrée exec du nœud Branch au nœud Set. 

    

Un nœud Branch vérifie si une condition est true ou false afin d'exécuter différentes actions pour chaque résultat. Créez ici une logique pour deux scénarios, true et false, en fonction de ce qui se produit si l'acteur en chevauchement est le joueur ou non. 

Pour appeler la fonction d'ajout de clé lorsque le joueur a touché la clé, procédez comme suit :

1. Si le résultat du nœud Branch est true, l'acteur peut ramasser des clés ; il faut donc déclencher la fonction d'événement de l'interface. Faites glisser la broche True du nœud Branch et ajoutez un nœud Fn BPIAdd Key (message).

   Vous ajoutez un nœud de message au lieu d'un nœud fonctionnel standard, car lorsque vous appelez une fonction d'interface de blueprint, vous envoyez un message. Le blueprint Cible ne répond que s'il implémente cette interface.

2. Faites glisser la broche Cible du nœud Fn BPIAdd Key et ajoutez un nœud Get Other Actor.

3. Faites glisser la broche Type de clé et ajoutez un nœud Get Key Type. Il existe une autre façon d'ajouter des références de variable. 

   

4. Lorsque votre clé est ramassée, elle doit disparaître après un court délai afin qu'elle ne puisse être ramassée à nouveau. Pour gérer cela, faites glisser la broche exec du nœud Fn BPIAdd Key et ajoutez un nœud Delay. Conservez la durée par défaut de 0,2. 

5. Lorsque le chronomètre expire, votre clé doit disparaître. Connectez donc un nœud Destroy Actor à la broche Terminé du nœud Delay. Assurez-vous que la broche Cible est définie sur self, ce qui signifie que l'acteur de clé doit se supprimer du niveau.

   

6. Enregistrez et compilez votre blueprint.

  Le graphique d'événement intégral de la clé devrait maintenant ressembler à ceci : 

Voici à nouveau le diagramme des ressources présenté au début de cette page, mais cette fois-ci avec un résumé de toutes les ressources et fonctions que vous avez créées et la manière dont elles s'associent pour créer l'apparence et le comportement de la clé : 

Tester la clé finale

Revenez dans votre niveau et ajoutez une clé de chaque couleur. Vous pouvez désormais essayer de ramasser les clés dans le jeu en marchant dessus.

Suivant

Dans la section suivante, vous modifierez le blueprint de la porte pour pouvoir en changer la couleur comme pour les clés et pour qu'elle reste fermée tant que le joueur n'a pas récupéré la clé correspondante.

• 

  Ouvrir des portes avec des clés

  Configurez le blueprint BP_DoorFrame pour que les portes changent de couleur et ne s'ouvrent qu'avec le blueprint BP_Key correspondant.