Bonus : faire apparaître de nouveaux cubes

Dans ce tutoriel, vous allez apprendre à créer un blueprint qui fait apparaître de nouveaux cubes dans le niveau lorsque le joueur se place sur un interrupteur. Utilisez cet objet de jeu pour permettre aux joueurs d'obtenir de nouveaux cubes dans une salle d'énigme où les cubes peuvent être perdus ou détruits. 

Pour le générateur de cubes, vous allez créer un blueprint qui ne contient que la fonctionnalité d'apparition, ce qui vous donne la possibilité d'utiliser n'importe quel élément de géométrie ou ressource graphique pour créer l'effet d'un cube tombant de cette géométrie. 

Il n'est pas indispensable de créer ce blueprint si vous avez suivi l'exemple de niveau, mais vous pouvez inclure cette mécanique de réapparition des cubes dans votre projet si vous continuez à développer votre jeu d'aventure et d'énigme.

Avant de commencer

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

• Principes de base des blueprints, notamment les interfaces de blueprint, les événements personnalisés et les variables.

Vous devez disposer des ressources suivantes créées dans le tutoriel Énigmes : interrupteurs et cubes :

• Blueprint BP_Cube

• Blueprint BP_Switch

• Interface de blueprint BPI_Interaction

Créer un nouveau blueprint

Vous devez commencer par créer une ressource de blueprint pour le générateur de cubes. Ce blueprint permet d'implémenter l'interface de blueprint BPI_Interaction afin qu'elle puisse répondre au blueprint BP_Switch, qui utilise les événements de cette interface.  

Pour configurer un nouveau blueprint, procédez comme suit :

1. Dans le navigateur de contenu, accédez au dossier Contenu > Jeu d'aventure > Concepteur > Blueprints > Activation.

2. Faites un clic droit dessus et sélectionnez Classe de blueprint. Dans la fenêtre de sélection de classe, sélectionnez la classe Acteur.

3. Nommez ce blueprint BP_CubeSpawn et ouvrez-le.

   

4. Dans l'éditeur de blueprint, accédez à l'onglet EventGraph.

5. Dans la partie supérieure de l'éditeur de blueprint, cliquez sur le bouton Paramètres de classe.

6. Accédez au panneau Détails , puis dans la section Interfaces , cliquez sur le menu déroulant Ajouter en regard de Interfaces implémentées et sélectionnez BPI_Interaction.

   

7. Cliquez sur Compiler, puis sur Enregistrer.

Une fois l'interface BPI_Interaction ajoutée, une nouvelle section appelée Interfaces apparaît dans le panneau Mon blueprint. Cette section contient les événements fnBPISwitchOff et fnBPISwitchOn qui font partie de l'interface d'interaction BPI.

Dans BP_CubeSpawn, vous utiliserez l'événement fnBPISwitchOn pour définir ce qui se passe lorsque le joueur marche sur un interrupteur et déclenche cet événement.

Créer la logique d'apparition des cubes

Avant d'implémenter la logique qui permet de faire apparaître les cubes, réfléchissez à la manière dont le système d'apparition des cubes doit fonctionner :

• Pour faire apparaître un cube, le joueur doit activer l'interrupteur, qui fait appel à l'interface que vous avez ajoutée dans la section précédente.

• Il convient de définir le nombre maximum de cubes que le joueur peut faire apparaître afin d'éviter de surcharger la zone de cubes.

• Si le joueur tente de faire apparaître plus de cubes que la valeur maximale, détruisez le premier cube qui apparaît. Pour suivre les cubes générés, vous utiliserez une variable de matrice.

• Le générateur de cubes doit faire appel à un bref chronomètre de délai de récupération afin que vous ne puissiez pas faire apparaître de nouveaux cubes trop rapidement.

Vérifier les conditions d'apparition des cubes

Avant de lancer le graphique d'événements du générateur de cubes, vérifiez si un nouveau cube peut apparaître et si le joueur a créé le nombre maximum de cubes. 

Pour vérifier si un nouveau cube peut apparaître, procédez comme suit :

1. Accédez au panneau Mon blueprint, puis dans la catégorie Interfaces, double-cliquez sur l'interface fnBPISwitchOn pour l'ajouter au graphique.

2. Faites glisser la broche d'exécution du nœud fnBPISwitchOn et créez un nouveau nœud Branch.

3. Sur le nœud Branch, faites glisser la broche Condition, sélectionnez Promouvoir vers la variable et nommez cette variable CanSpawn. Vous utiliserez cette variable pour vérifier si le délai de récupération est terminé.

   

4. Dans le panneau Mon blueprint, créez une nouvelle variable nommée CubesSpawned de type entier. Cette variable permet de suivre les cubes qui apparaissent dans le niveau.

5. Créez une autre variable nommée MaxNumCubes. Cette variable définit le nombre maximum de cubes que le joueur peut faire apparaître.

6. Définissez la variable MaxNumCubes :

   1. Définissez son type sur Entier.

   2. Cliquez sur l'icône d'œil correspondante pour la rendre publique et modifiable.

   3. Dans le panneau Détails , cliquez sur le champ Catégorie et saisissez Configuration. 

   4. Cliquez sur Compiler et définissez la valeur par défaut de la variable sur 3.

      À ce stade, votre liste de variables doit ressembler à ceci :

      

7. Faites glisser la broche True du nœud Branch, puis ajoutez un deuxième nœud Branch.

8. Faites glisser la broche Condition du deuxième nœud Branch, puis ajoutez un nœud Less Than (<).

9. Configurez le nœud Less Than pour vérifier si le nombre de cubes générés est inférieur au nombre maximum de cubes autorisés : 

   • Dans la liste des variables , faites glisser CubesSpawned sur la broche supérieure du nœud Less Than.

   • Faites glisser la variable MaxNumCubes sur la broche d'entrée inférieure.

     

Compter les cubes qui sont apparus et éliminer les cubes supplémentaires

Si le nombre actuel de cubes que le joueur a fait apparaître est inférieur à la valeur maximale, l'exécution passe par la broche True du deuxième nœud Branch. Dans ce cas, vous pouvez passer directement à la logique qui ajoute 1 au nombre de cubes avant qu'un cube apparaisse.

Pour augmenter le nombre de cubes qui apparaissent, procédez comme suit :

1. Faites glisser la broche True du nœud Branch, puis ajoutez un nœud Increment Int. Déplacez le nouveau nœud pour ajouter de l'espace supplémentaire entre celui-ci et le nœud Branch.

2. Dans la liste Variables , faites glisser CubesSpawned sur la broche d'entrée du nœud Increment Int.

   

     

Ensuite, ajoutez la logique pour le scénario inverse, où la valeur de la variable CubesSpawned est supérieure à la valeur de la variable MaxNumCubes, ou lorsque l'exécution passe par la broche False du nœud Branch. Si le joueur a atteint le nombre maximum de cubes, détruisez le cube le plus ancien avant d'en faire apparaître un nouveau.

Pour détruire un cube et faire place à un nouveau, procédez comme suit :

1. Faites glisser la broche False du nœud Branch, puis ajoutez un nœud Destroy Actor.

2. Faites glisser la broche Cible du nœud Destroy Actor, puis ajoutez un nœud Get (a copy).

3. Laissez la seconde broche d'entrée du nœud Get sur 0, car la liste d'une matrice commence à 0 et vous souhaitez récupérer le premier élément.

4. Faites glisser le nœud d'entrée Array du nœud Get, puis sélectionnez Promouvoir vers la variable.

5. Nommez la nouvelle variable SpawnedCubes. Cette matrice sert à stocker chaque cube que le joueur fait apparaître dans le niveau.

   

6. Faites glisser la broche d'exécution du nœud Destroy Actor, puis ajoutez un nœud Remove Index.

7. Faites glisser son entrée Array, puis ajoutez un nœud de référence Get Spawned Cubes.

   

8. Double-cliquez sur le lien entre le deuxième nœud Branch et le nœud Increment Int pour créer un nœud de redirection mobile. Faites glisser le nœud de redirection plus près du nœud Increment Int.

9. Reliez la broche d'exécution de sortie du nœud Remove Index au nœud de redirection.

   

   (Vous pouvez également relier le nœud Remove Index directement au nœud Increment Int.)

Avant qu'un cube n'apparaisse, le blueprint incrémente le compteur CubesSpawned ou supprime un cube, puis incrémente à nouveau le compteur CubesSpawned. Vous allez maintenant ajouter la logique qui fait apparaître un nouveau cube.

Faire apparaître un cube

Après vous être assuré que le joueur peut créer un cube et avoir vérifié qu'il n'y a pas trop de cubes dans le niveau, vous pouvez faire apparaître un nouvel acteur BP_Cube.

Pour faire apparaître un nouveau cube, procédez comme suit :

1. Faites glisser la broche d'exécution du nœud Add, puis ajoutez un nœud Spawn Actor from Class.

2. Configurez le nœud SpawnActor : 

   1. Cliquez sur le menu déroulant en regard de la broche Classe, puis recherchez et sélectionnez BP_Cube. Le nœud SpawnActor NONE est renommé SpawnActor BP Cube.

   2. Faites un clic droit sur la broche orange Transformation d'apparition et sélectionnez Diviser la broche de structure. Trois nouvelles broches remplacent la broche Transformation d'apparition : Emplacement de la transformation d'apparition, Rotation de la transformation d'apparition et Échelle de la transformation d'apparition. 

      

      Vous devez faire un clic droit sur la broche circulaire Transformation d'apparition et non sur tout le nœud.

   3. Faites un clic droit dans le graphique d'événements, puis recherchez et sélectionnez un nœud Get Actor Transform. Faites un clic droit sur la broche Valeur de retour et sélectionnez Diviser la structure. Reliez les broches Emplacement et Rotation aux broches correspondantes du nœud Spawn Actor.

      

3. Faites glisser la broche d'exécution du nœud SpawnActor, puis et ajoutez un nœud Add sous la catégorie Matrice (vous pouvez aussi rechercher Add Array et sélectionner le nœud Add).

4. Sur le nœud Add Array, procédez comme suit :

   1. Faites glisser la broche d'entrée Matrice et ajoutez un nœud Get Spawned Cubes.

   2. Reliez la broche d'entrée inférieure du nœud à la broche Valeur de retour du nœud SpawnActor. 

      

5. Lorsque le joueur fait apparaître un cube, il ne doit pas pouvoir en faire apparaître un autre avant l'expiration du chronomètre de délai de récupération. Faites glisser la broche d'exécution du nœud Add Array et ajoutez un nœud Set Can Spawn. Laissez le paramètre Peut apparaître sur false (case non cochée).

   

Implémenter un chronomètre de délai de récupération

Utilisez la variable CanSpawn et un nœud Delay pour empêcher le joueur de faire apparaître un autre cube avant un délai défini.

Pour créer et déclencher un événement qui réinitialise le chronomètre du délai de récupération après apparition du cube, procédez comme suit :

1. Faites un clic droit dans un espace vide du graphique d'événements, puis recherchez et sélectionnez Ajouter un événement personnalisé.

2. Nommez le nouvel événement EvResetSpawn et déplacez-le sous le nœud Event fnBPISwitchOn.

3. Faites glisser la broche d'exécution du nœud d'événement EvResetSpawn, puis ajoutez un nœud Delay. 

   

4. Sur le nœud Delay , faites glisser la broche Durée et sélectionnez Promouvoir vers la variable. Nommez la variable SpawnCooldown.

5. Configurez la nouvelle variable SpawnCooldown :

   1. Assurez-vous qu'elle est de type Float.

   2. Cliquez sur l'icône d'œil correspondante pour la rendre publique et modifiable.

   3. Définissez sa catégorie sur Configuration.

   4. Cliquez sur Compiler, puis définissez sa valeur par défaut sur 1. Votre liste complète de variables doit ressembler à ceci :

      

6. Faites glisser la broche Terminé du nœud Delay, puis ajoutez un nœud Set Can Spawn. Assurez-vous que la valeur Peut apparaître de ce nœud est définie sur true. 

   

7. Revenez au nœud Set Can Spawn à la fin de votre logique d'apparition de cubes. Faites glisser la broche d'exécution du nœud Set Can Spawn, puis ajoutez un nœud EvResetSpawn pour déclencher l'événement et le délai de récupération d'apparition. 

   

8. Cliquez sur Enregistrer, puis sur Compiler.

Votre graphique d'événements doit maintenant ressembler à ceci :

Vous pouvez maintenant quitter l'éditeur de blueprint et revenir à l'éditeur de niveau.

Ajoutez le blueprint d'apparition de cubes au niveau

Vous allez à présent configurer un BP_CubeSpawn et un BP_Switch dans le niveau. 

Le blueprint du générateur de cubes ne possède pas de composants visuels. Vous pouvez donc le placer au sein de n'importe quelle géométrie ou ressource graphique pour créer l'effet d'un cube qui tombe de cette géométrie. 

Choisissez un emplacement dans votre niveau et utilisez les maillages du dossier Contenu > LevelPrototyping > Maillages pour ébaucher une géométrie afin de représenter le générateur de cubes. 

Si vous utilisez l'exemple de niveau, vous pouvez le placer dans l'espace au fond de la pièce 1. Dans cet exemple, nous allons utiliser un cylindre pour représenter un tuyau dans lequel les cubes peuvent apparaître et duquel ils peuvent tomber.

Ensuite, pour configurer un BP_CubeSpawn dans un niveau, procédez comme suit :

1. Dans le navigateur de contenu, accédez à Contenu > Jeu d'aventure > Concepteur > Blueprints > Activation.

2. Faites glisser le blueprint BP_CubeSpawn à l'emplacement souhaité dans le niveau. 

3. Dans le navigateur de contenu, faites glisser le blueprint BP_Switch dans le niveau qui se trouve dans la ligne de mire du générateur de cubes. 

   

4. Sélectionnez l'acteur BP_Switch dans le niveau.

5. Dans le panneau Détails , sous la section Configuration , ajoutez un nouvel élément de matrice à la liste des objets d'interaction.

6. Utilisez le menu déroulant en regard de Index [0] pour sélectionner l'acteur BP_CubeSpawn. L'événement fnBPISwitchOn de cet interrupteur est ainsi transmis à l'acteur BP_CubeSpawn.

   

   

7. Sélectionnez l'acteur BP_CubeSpawn. Vous pouvez aussi modifier la variable Nombre maximum de cubes autorisés pour définir le nombre de cubes que vous souhaitez autoriser dans le niveau.

À présent, lorsque vous jouez au jeu, vous pouvez appuyer sur l'interrupteur pour faire apparaître de nouveaux cubes.

Pour continuer

Pour continuer à travailler sur votre niveau en ajoutant des matériaux, de l'éclairage, des effets de post-traitement, des sons et des effets visuels, consultez la série de tutoriels Artist Track :

• 

  Art Pass for a Puzzle Adventure Game

  Learn how you can apply art workflows with materials, sounds, and visual effects to the Puzzle Adventure game.

Si vous souhaitez empaqueter votre projet en tant que programme autonome pour le tester et le partager, consultez la page suivante :

• 

  Empaquetage des projets Unreal Engine

  Empaqueter les projets de jeu Unreal Engine pour la distribution.