GameState

Les trois « games states » principaux sont en places et utilisables depuis l’operator engine.

J’ai du rajouter un mécanisme pour ne pas générer tout le contenu du jeu mais uniquement une partie pour ne pas utiliser trop de RAM et aussi pour ne pas que la génération procédurale soit trop longue.

Par exemple lorsque l’operateur « InGameState » est exécuté, je génère les niveaux du jeu en entrées « Level_01 » et « Level_02 » uniquement sur demande. C’est l’opérateur « InGameState » qui est en charge de générer ce qu’il a besoin. Si le joueur est au niveau 1, je demande la création de ce niveau directement dans le code « EngineRunner.CallCreateFromOp(Level_01) ».

MainMenu

InGame

HiScore

Il faut que je travaille encore sur le gameplay avant de me concentrer sur le visuel. Je voudrais rajouter des téléporteurs, des tableaux bonus et des boss.

Publicité

Générateur des villes

Dans le jeux original, les niveaux commencent et finissent par une ville en passant par des fôrets, deserts … j’ai donc réalisé un générateur de ville.

Le générateur se base sur des Tiles3D de 16x16x16 voxels dessinés sous MagicaVoxel.
Il y a 18 Tiles pour l’instant, je pourrais en rajouter pour faire des variantes sur les bâtiments plus tard.
Il y a des Tiles pour les bords des bâtiments, pour le dessus, pour le centre …

Tiles sous MagicaVoxel

Pour placer les bâtiments, je gère un quadtree sur la surface du niveau que je subdivise d’une profondeur aléatoire ce qui permet d’avoir des bâtiments de tailles différentes. Sur chaque cellules du quadtree, toujours de manière aléatoire, j’évalue la possibilité de créer un bâtiment ou pas.

Quatree avec en jaune les cellules indiquant la création d’un bâtiment.

Je vais travailler maintenant sur la gestion des gamestates notamment pour le menu principal et les cinématiques.

Premier test d’un niveau

Voici en vidéo l’avancement d’un premier niveau de test :

J’ai rajouté également l’enchainement des niveaux et le chargement des données des différents niveaux en différé. La prochaine étape sera de rajouter la génération des villes en début et en fin de niveau comme sur l’original !

Wave’s Paths

L’éditeur de spline est maintenant développé. (c’est vraiment cool de travailler avec la librairie Dear Imgui)

Pour pouvoir définir une spline j’ai rajouté un nouvel opérateur SplineFx qui peut être directement être utilisé par mon langage script. La fonction Spline(name, t, dim) me permet de récupérer la valeur de sortie de l’opérator SplineFx.

Le langage script me permet de modifier les paramètres des opérateurs et de définir des animations. Grace à l’opérateur SplineFx, pour les ennemies par exemple, je peux maintenant définir des courbes d’animations pour leurs déplacements.

La prochaine étape sera de rajouter la possibilité aux ennemies de tirer dans les IA et de tester un niveau afin d’améliorer l’ensemble.

Waves Spawner

Maintenant que je peux paramétrer mes vagues d’ennemies grâce au « WaveEmitter » (choix du sprite, nombre d’ennemies dans la vague, leur formation …) je dois les faire apparaitre tout au long du niveau du jeu.

Pour ne pas le faire manuellement j’ai créé la classe « WavesSpawner » qui se chargera de positionner et choisir des « WaveEmitter » aléatoirement.

Je voulais également incrémenter la difficulté du jeu tout au long du jeu. Maintenant un « WaveEmitter » a une nouvelle propriétée « Strong » qui me permet de donner une force à la vague. Au début du niveau « WavesSpawners » choisira des « WaveEmitter » de force faible et au fur et à mesure de la progression dans le niveau des « WaveEmitter » plus fort.

J’aimerai maintenant pouvoir améliorer les déplacements de mes vagues, je vais développer un éditeur de spline avec ImGUI…

WaveEmitter

L’opérateur « WaveEmitter » me permet maintenant de spécifier par vague d’ennemies, la forme de leur regroupement.

Je m’explique, avant je pouvais uniquement choisir d’avoir 10 vaisseaux espacés le long d’un linéaire. J’ai donc rajouté un paramètre « type de regroupement » qui est un énuméré avec pour choix possible: Linéaire, Rectangle, Triangle et Diamant, dont les résultats peuvent être les suivants:

Regroupement de type Triangle

Regroupement de type Diamant

La prochaine étape sera de rajouter une notion d’aléatoire pour les vagues en jouant sur leur temps d’apparitions mais aussi sur la position verticale. Et voir ce que cela donne sur un niveau complet.

Niveaux procéduraux

Les décors sont générés procéduralement. L’avantage c’est que je peux générer des niveaux indéfiniment mais tout n’est pas aussi simple.

Pour commencer la camera, qui suit une trajectoire linéaire sur l’axe des X peut se retrouver à l’intérieur d’une montagne par exemple. Mais comment ne pas se retrouver avec un point de vue à l’intérieur du décors ?

On pourrait faire que la camera suive le relief en prenant de l’altitude. On pourrait également utiliser l’algorithme du « path finding » afin de déterminer un chemin à travers le niveau. Pour l’instant pour les premiers tests j’ai décidé de modifier les générateurs de décors en créant un couloir autour de la camera. Ca fonctionne pour mes deux types de niveaux on verra par la suite comment aller plus loin.

Les ennemies doivent être placés le long du chemin de la camera et commencer à se déplacer dès qu’ils se retrouvent dans le champs de la camera. J’utilise l’opérateur « WaveEmitteur » qui prend en paramètre le nombres de vagues d’acteurs à positionner le long du chemin de la camera et le nombres d’acteurs par vague. Les vaques sont espacées en fonction d’un temps fixe, certainement je rajouterais un temps aléatoire plus tard. Par « WaveEmitteur » on ne peut choisir qu’un seul type d’acteur. On peut spécifier l’IA des acteurs grâce à un opérateur, ici on utilise « IA_MonsterShip01 » qui ajoute un comportement d’attaque dès que le joueur est proche.

L’éditeur

Pour réaliser l’éditeur du jeu, j’ai repris le travail que j’avais fait en 2008 sur le générateur de texture FxGen

Cet éditeur permet de générer des textures de 2048×2048 à partir d’un fichier de 1ko ! Ca utilise des générateurs procéduraux et c’est basé sur le travail du groupe de démo Farbraush et de leur outil Werkkzeug.

L’éditeur de Sanxion utilise maintenant l’excellent DearImgui pour l’interface avec un nouveau moteur de node qui me permet d’aller beaucoup plus loin que ma version de 2008.

J’ai la possibilité d’animer les variables d’un node depuis un langage script, d’exécuter des parties du graph en rajouter des conditions et d’avoir des évènements entre node.

 

 

Sanxion

En 1986 je me souviendrai toujours du jour ou un ami m’a montré dans son grenier sur son C64 le jeu Sanxion.

Sanxion est un shoot-them-up à scrolling horizontal. Le but est  de traverser les niveaux en tuant les ennemis et en évitant les obstacles. Le joueur peut contrôler la vitesse du scrolling ce qui permettait de finir les niveaux le plus rapidement possible.

La musique composée par Rob Hubbard fait partie des meilleures musiques du C64.

Il existe une adaptation du jeu sur ZX Spectrum uniquement, ce que je trouve vraiment dommage et j’ai donc décidé d’en faire une adaptation pour PC.

J’ai commencé à développer le jeu en C# en utilisant le Framework MonoGame qui est une version multiplateforme de XNA.

Le rendu est de type voxel pour garder un look retro 8 bits. Les voxels permettront au  joueur d’interagir avec le décors en pouvant le détruire lors des explosions ou des tirs.

Les niveaux sont générés procéduralement ce qui me permettra de rendre le jeu plus intéressant en ayant un nombres de niveaux infinis.

Ce blog vous l’aurez compris concernera le développement de mon adaptation du jeu Sanxion sur PC !