Advertisement
  1. Game Development
  2. Platform Agnostic
Gamedevelopment

Génération procédurale pour les puzzles simples

by
Length:MediumLanguages:

French (Français) translation by New Lune (you can also view the original English article)

Final product image
What You'll Be Creating

Les puzzles font partie intégrante du gameplay de nombreux genres. Que ce soit simple ou complexe, le développement de puzzles manuellement peut devenir rapidement encombrant. Ce tutoriel vise à alléger ce fardeau et ouvre la voie à d'autres aspects plus amusants de la conception.

Ensemble, nous allons créer un générateur pour composer des puzzles simples "imbriqués" procéduriers. Le type de puzzle sur lequel nous allons nous concentrer est le traditionnel "verrouillage et clé" le plus souvent itéré comme: obtenir x élément pour déverrouiller y zone. Ces types de puzzles peuvent devenir ennuyeux pour les équipes travaillant sur certains types de jeux, en particulier dungeon crawlers, sandboxes et jeux de rôle où les énigmes sont plus souvent invoqués pour le contenu et l'exploration.

En utilisant la génération procédurale, notre objectif est de créer une fonction qui prend quelques paramètres et retourne un atout plus complexe pour notre jeu. L'application de cette méthode fournira un retour exponentiel sur le temps du développeur sans sacrifier la qualité du gameplay. Le consternation développeur peut également décliner comme un effet secondaire heureux.

Que dois-je savoir?

Pour suivre le long, vous aurez besoin de se familiariser avec un langage de programmation de votre choix. Puisque la plupart de ce que nous discutons est seulement des données et généralisé en pseudocode, tout langage de programmation objet orienté suffira.

En fait, certains éditeurs de glisser-déposer fonctionnent également. Si vous souhaitez créer une démo jouable du générateur mentionné ici, vous aurez également besoin d'une certaine familiarité avec votre bibliothèque de jeux préférée.

Création du générateur

Commençons par regarder un pseudocode. Les éléments de base de notre système vont être les clés et les pièces. Dans ce système, un joueur est interdit d'entrer dans la porte d'une pièce à moins d'avoir sa clé. Voici ce que ces deux objets ressembleraient à des classes:

Notre classe clé ne contient que deux informations: l'emplacement de la clé, et si le joueur a cette clé dans son inventaire. Ses deux fonctions sont l'initialisation et le ramassage. L'initialisation détermine les bases d'une nouvelle clé, tandis que la reprise est pour quand un joueur interagit avec la clé.

À son tour, notre classe de pièce contient également deux variables: isLocked, qui détient l'état actuel du verrou de la salle, et assocKey, qui contient l'objet clé qui déverrouille cette pièce spécifique. Il contient également une fonction d'initialisation—l'une pour appeler pour déverrouiller la porte, et l'autre pour vérifier si la porte peut être ouverte.

Une seule porte et clé sont amusantes, mais nous pouvons toujours pimenter avec nidification. La mise en œuvre de cette fonction nous permettra de créer des portes à l'intérieur des portes tout en servant de notre générateur primaire. Pour maintenir la nidification, nous devrons ajouter quelques autres variables à notre porte aussi:

Ce code de générateur effectue les opérations suivantes:

  1. Prenant le paramètre pour notre puzzle généré (spécifiquement combien de couches profondément une pièce imbriquée devrait aller).

  2. Création de deux tableaux: un pour les chambres qui sont vérifiées pour l'imbrication potentielle, et un autre pour l'enregistrement des chambres qui sont déjà imbriquées.

  3. Créer une salle initiale pour contenir la scène entière, puis l'ajouter au tableau pour que nous puissions vérifier plus tard.

  4. Prendre la salle à l'avant du tableau pour passer à travers la boucle.

  5. Vérification de la profondeur de la pièce actuelle par rapport à la profondeur maximale fournie (cela décide si nous créons une autre chambre d'enfant ou si nous terminons le processus).

  6. Établir une nouvelle salle et le remplir avec les informations nécessaires de la salle des parents.

  7. Ajout de la nouvelle pièce dans les roomsToCheck tableau et déplacer la pièce précédente vers le tableau terminé.

  8. Répéter ce processus jusqu'à ce que chaque pièce dans le tableau est terminée.

Maintenant, nous pouvons avoir autant de pièces que notre machine peut manipuler, mais nous avons encore besoin de clés. L'implantation des clés a un défi majeur: la solvabilité. Partout où nous plaçons la clé, nous devons nous assurer qu'un joueur peut y accéder! Peu importe l'excellent cache de clé caché semble, si le joueur ne peut pas l'atteindre, il ou elle est effectivement piégé. Pour que le joueur continue le puzzle, les clés doivent être obtenues.

La méthode la plus simple pour assurer la solvabilité dans notre énigme est d'utiliser le système hiérarchique des relations d'objet parent-enfant. Puisque chaque chambre réside dans une autre, nous nous attendons à ce qu'un joueur ait accès au parent de chaque chambre pour l'atteindre. Ainsi, tant que la clé est au-dessus de la salle sur la chaîne hiérarchique, nous garantissons que notre joueur est en mesure d'accéder.

Pour ajouter la génération de clés à notre génération procédurale, nous mettrons le code suivant dans notre fonction principale:

Ce code supplémentaire va maintenant produire une liste de toutes les salles qui sont au-dessus de votre salle actuelle dans la hiérarchie des cartes. Ensuite, nous choisissons l'un de ceux au hasard, et définissons l'emplacement de la clé de cette salle. Après cela, nous assignons la clé à la pièce qu'il déverrouille.

Lorsqu'on l'appelle, notre fonction générateur va maintenant créer et retourner un nombre donné de salles avec des clés, ce qui peut économiser des heures de développement!

Cela enveloppe la partie pseudocode de notre générateur de puzzles simples, alors maintenant, mettons-le en action.

Démonstration de génération de puzzle procédurale

Nous avons construit notre démo à l'aide de JavaScript et de la bibliothèque Crafty.js pour la garder aussi légère que possible, ce qui nous permet de garder notre programme sous 150 lignes de code. Voici trois composantes principales de notre démo:

  1. Le joueur peut se déplacer à travers chaque niveau, ramasser les clés et déverrouiller les portes.

  2. Le générateur que nous utiliserons pour créer une nouvelle carte automatiquement chaque fois que la démo est exécutée.

  3. Une extension pour notre générateur à intégrer avec Crafty.js, qui nous permet de stocker des informations d'objet, de collision et d'entité.

Le pseudocode ci-dessus agit comme un outil d'explication, de sorte la mise en œuvre du système dans votre propre langage de programmation nécessitera une certaine modification.

Pour notre démonstration, une partie des classes est simplifiée pour une utilisation plus efficace en JavaScript. Cela inclut la suppression de certaines fonctions liées aux classes, car JavaScript permet un accès plus facile aux variables dans les classes.

Pour créer la partie du jeu de notre démo, nous initialisons Crafty.js, puis une entité joueur. Ensuite, nous donnons à notre entité joueur les quatre contrôles de base de direction et une détection de collision mineure pour empêcher l'entrée dans les chambres fermées.

Les salles reçoivent maintenant une entité Crafty, stockant des informations sur leur taille, leur emplacement et leur couleur pour la représentation visuelle. Nous allons également ajouter une fonction de dessin pour nous permettre de créer une pièce et de le dessiner à l'écran.

Nous fournirons des clés avec des ajouts similaires, y compris le stockage de son entité Crafty, la taille, l'emplacement et la couleur. Les clés seront également codées par couleur pour correspondre aux salles qu'ils déverrouillent. Enfin, nous pouvons maintenant placer les clés et créer leurs entités en utilisant une nouvelle fonction de dessin.

Enfin, nous allons développer une petite fonction d'aide qui crée et retourne une valeur de couleur hexadécimale aléatoire pour supprimer le fardeau de choisir les couleurs. Sauf si vous aimez la coloration des couleurs, bien sûr.

Que dois-je faire ensuite?

Maintenant que vous avez votre propre générateur simple, voici quelques idées pour étendre nos exemples:

  1. Port le générateur pour permettre l'utilisation dans votre langage de programmation de choix.

  2. Étendez le générateur pour inclure la création de salles de branchement pour une personnalisation supplémentaire.

  3. Ajoutez la possibilité de gérer les entrées de plusieurs pièces de notre générateur pour permettre des puzzles plus complexes.

  4. Étendez le générateur pour permettre le placement des clés dans des endroits plus complexes afin d'améliorer la résolution des problèmes des joueurs. Cela est particulièrement intéressant lorsque combiné avec des chemins multiples pour les joueurs.

Finissons-en

Maintenant que nous avons créé ce générateur de puzzle ensemble, utilisez les concepts présentés pour simplifier votre propre cycle de développement. Quelles sont les tâches répétitives que vous faites vous-même? Qu'est-ce qui vous dérange le plus dans la création de votre jeu?

Les chances sont, avec un peu de planification et la génération de procédures, vous pouvez rendre le processus beaucoup plus simple. Espérons que notre générateur vous permettra de vous concentrer sur les parties les plus attrayantes de la fabrication de jeux tout en coupant le banal.

Bonne chance, et je vais vous voir dans les commentaires!

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.