Skip to content

Catégorie : Devblog

Devblog #3 : Nouveautés et Progrès dans Forge Keepers

Salut à tous !

C’est avec enthousiasme que je vous présente ce troisième devblog de Forge Keepers. Bien que je n’ai pas pu avancer lors de la première semaine de septembre, je me suis bien rattrapé récemment, en apportant de nombreux changements et améliorations. Depuis le dernier article, beaucoup de choses ont évolué, et j’ai continué à explorer les possibilités offertes par Godot. Voici un aperçu des principales modifications, des réussites et des défis rencontrés.

Mise à jour vers Godot 4.3

Je ne pensais pas que cette mise à jour aurait un grand impact, mais elle a impliqué quelques ajustements, notamment avec le remplacement du composant TileMap par TileMapLayer.

Ce changement a nécessité de gérer les calques de tuiles dans différents nœuds plutôt que dans un seul, mais heureusement, cela n’a pas trop perturbé le développement.

Transition vers un Modèle de Composants pour les Armes

Comme prévu lors du dernier devblog, j’ai travaillé sur la modularisation des armes en utilisant un système de composants. L’objectif était de créer une arme de base, avec des caractéristiques, un nombre de munitions, des projectiles et une méthode simple de tir. Ensuite, des composants supplémentaires, tels que Rechargeable et Tir Chargé, devaient enrichir les fonctionnalités de l’arme.

Initialement, ces composants étaient des nœuds Godot, mais n’utilisant pas leurs capacités spécifiques, je les ai remplacés par des classes C# basiques. Cependant, cette solution n’a pas fonctionné pour les fonctionnalités complexes que je souhaitais implémenter, comme la gestion des états de rechargement ou de charge d’attaque, car ces états interféraient avec le comportement normal de l’arme. Je me suis rendu compte que j’avais surtout besoin d’une gestion d’état plutôt que de composants pour ces cas-là.

Tests Unitaires

J’ai commencé à implémenter des tests unitaires pour vérifier la validité des composants, notamment pour les nouvelles fonctionnalités des armes et des projectiles. Cela permet de garantir que chaque composant fonctionne comme prévu.

Finalement, cet ajout était plutôt prématuré. Je me rends compte que j’aurais dû me concentrer sur la mise en place d’un gameplay simple plutôt que de vouloir avoir quelque chose de parfait tout de suite.

Améliorations de la Navigation et du Tilemap

Avec l’arrivée de TileMapLayer, j’ai voulu ajouter un bâtiment, la Forge, dans la carte. Malheureusement, cela a causé des problèmes de navigation pour les IA, car l’obstacle n’était pas pris en compte. Après plusieurs heures de recherche et d’essais, j’ai finalement trouvé une solution avec NavigationRegion2D. Voici comment j’ai résolu le problème :

  1. Utilisation de NavigationRegion2D pour gérer les zones navigables :
    • Génération d’une région de navigation incluant toute la zone devant être navigable.
    • Configuration d’un groupe de nœuds (sorte de tag) nommé collision.
    • Configuration de NavigationRegion2D pour prendre en compte les collisions des nœuds présents dans le groupe collision.
  2. Intégration de la Tilemap et de la Forge dans ce groupe pour les considérer comme obstacles.
  3. Génération du polygone de navigation après la création de la Tilemap.

Refonte de la Génération de Carte

J’ai profité de cette réorganisation pour effectuer un rework complet de la génération de carte. La structure des fichiers a été optimisée, et la transition vers la première scène de génération de carte a été clarifiée, rendant le développement futur plus modulable. Les spawners ont également été améliorés pour mieux gérer l’apparition des ennemis, limitant ainsi leur nombre sur un même point de spawn.

Intégration d’une Machine à États

J’ai cherché un plugin visuel pour mettre en place des machines à état et suis tombé sur LimboAI, une solution prometteuse.

Cependant, l’intégration de ce plugin nécessite d’écrire le code en GDScript, ou de reconstruire Godot avec cette extension pour l’utiliser en C#. Après réflexion, j’ai décidé de continuer en C# et de voir comment intégrer cette extension via la compilation de Godot incluant cette extension. Je crois les doigts pour la suite.

Prochaines Étapes

Je réalise que ma vision de Forge Keepers évolue et que j’ai tendance à me disperser. J’ai décidé d’arrêter de vouloir construire directement le jeu final, et plutôt de créer des petits morceaux de gameplay qui m’intéressent afin de mieux maîtriser Godot et d’expérimenter rapidement. Je vais donc mettre en pause la génération de carte et me concentrer sur la mise en place d’une IA simple et d’un système de combat sur une scène fixe. De plus, je vais abandonner le tir automatique de Brotato, qui ne correspond plus à ce que je veux pour le jeu à long terme.

Merci à tous de suivre cette aventure de développement. Chaque nouvelle itération me permet de découvrir Godot un peu plus et me rapproche, je l’espère, de la création de Forge Keepers. À très bientôt pour de nouvelles mises à jour !

Devblog #2: Première itération et test de Godot

Après vous avoir partagé mes idées initiales, voici un compte rendu de ma première semaine de développement.

Création du Personnage Jouable

Le personnage principal est maintenant en place. J’ai implémenté les bases du mouvement avec Godot, en utilisant un CharacterBody2D pour gérer les déplacements et les collisions avec l’environnement. Le personnage dispose également de deux animations principales : une pour le déplacement et une pour l’état d’inactivité. Le design vient pour l’instant d’un pack d’asset acheté il y a quelques années.

La mise en place avec Godot s’est déroulée sans difficulté particulière.

Création d’un système de génération de carte

La carte se génère automatiquement grâce à une génération automatique du terrain qui se base sur un bruit de type Perlin. Ce bruit est ensuite transformé en différents types de terrain (sol, mur) selon une valeur seuil. Ce terrain est ensuite interprété par un système de tilemap, qui gère les transitions pour créer une carte visuellement cohérente.

J’ai dû consulter quelques tutoriels pour maîtriser la gestion des tilemaps et la génération de bruit dans Godot, mais globalement, le processus s’est avéré assez simple. C’est à ce moment que j’ai switch entre le GDScript et le C# pour être plus à l’aise dans le dev.

Système d’Armes et de Projectiles

J’ai commencé le développement d’un ensemble de composants permettant de gérer les armes et les projectiles. Chaque arme a ses caractéristiques et ses projectiles. Pour l’instant j’ai 3 armes différentes :  un orbe de feu tirant des boules de feu sur l’ennemis le plus proche, un orbe d’eau tirant des projectiles qui entourent le personnage et un pistolet laser qui suit l’ennemi le plus proche. Les projectiles peuvent infliger des dégâts aux ennemis, et j’ai également mis en place des systèmes pour gérer les collisions avec l’environnement.

Là, les choses sont devenus plus complexe. C’est ici que les différences avec Unity ont vraiment commencé à se faire sentir, en particulier en ce qui concerne le système de Nodes de Godot. Par exemple, contrairement à un gameobject dans Unity, un Node ne peut avoir qu’un seul script. La solution pour gérer la composition ? Placer un sous-node pour chaque composant, avec son propre script associé. J’ai pu aussi tester les Resources à la place des ScriptableObject.

Petit bémol avec Godot en C#, qui ne reconnaît pas correctement les Resources créées via C# dans son interface. Cela fonctionne tout de même, mais il est nécessaire de créer une Resource vide avant de lui associer le script approprié.

Managers et Système Global

Pour structurer le projet, j’ai créé plusieurs managers qui sont chargés en singleton via l’autoload de Godot :

  • GameManager : Gère l’état global du jeu et les interactions principales comme l’enregistrement du joueur.
  • InputManager : Gère les entrées du joueur et déclenche les actions correspondantes.
  • SceneManager : Gère le chargement des scènes et la génération de la carte. Cela inclut un écran de chargement dynamique pour une meilleure immersion.

L’autoload est facile à mettre en place une fois qu’on sait qu’il existe 🙂

Composants Clés

Plusieurs composants essentiels sont maintenant en place :

  • HealthComponent : Gère la santé des entités et déclenche des événements lorsqu’elles subissent des dégâts ou meurent.
  • DommageableComponent : Permet à une entité de recevoir des dégâts.
  • ClosestTargetLocatorComponent : Localise la cible la plus proche pour les armes et projectiles.

Thème Graphique de l’UI

J’ai commencé à travailler sur le thème graphique de l’interface utilisateur (UI) du jeu. Cette phase m’a prise pas mal de temps entre la recherche dans mes pack d’assets et la compréhension du système d’UI de Godot.

Ici grosse complication avec Godot pour comprendre le système d’UI. J’ai perdu beaucoup de temps dessus pour juste mettre en place le TitleScreen. J’aime bien l’idée d’avoir une gestion de Thèmes mais par contre les alignements de composant et leurs tailles etc… C’était vraiment galère…

Démo

Prochaines Étapes

Le test de Godot avance bien mais il reste encore beaucoup à faire ! Voici ce que j’ai prévu pour les prochaines étapes :

  • Gestion de composant: Travailler sur sa mise en place avec Godot pour la création la plus simple de système modulaire.
  • Réflexion sur le gameplay souhaité
  • Création de nouveau ennemis : Implémenter des nouveaux ennemis pour augmenter la diversité dans le jeu et continuer à mettre en place les composants me permettant de gérer tous les types d’ennemis
  • Nouvelles armes : Pour suivre la même voie que pour les ennemis, le système d’armes et projectiles est encore très rudimentaire, du coup j’ai bien envie de voir les possibilités d’armes que je peux mettre en place avec et le faire évoluer au besoin
  • Système de compétences : Mettre en place un système basique de compétences pour personnaliser davantage le gameplay.

Je suis vraiment enthousiaste après cette première semaine de travail sur ‘Forge Keepers’ et mes premiers pas avec Godot. Je suis bien conscient que ça va me ralentir au début puisque je n’aurais pas l’expérience que j’ai avec Unity, mais le fait d’avoir choisi de coder en C# plutôt qu’en GDScript devrait me faciliter la transition. Restez à l’écoute pour plus de mises à jour, et merci de suivre cette aventure de développement !

À bientôt pour le prochain devblog !

Devblog #1 : Premier aperçu de « Forge Keepers »

Salut à tous!

Je suis très heureux de vous présenter le tout premier devblog de ‘Forge Keepers’, un projet sur lequel je viens tout juste de me lancer. C’est un projet qui mêle des éléments de rogue-like, de défense de base, et d’exploration avec une forte dose de sci-fi et de fantasy. Aujourd’hui, je vais vous donner un aperçu de ce qui a été fait jusqu’à présent.

Concept et Inspiration

« Forge Keepers » s’inspire de plusieurs jeux que j’adore, comme Brotato, Tribes of Midgard, et Gunfire Reborn. Mon objectif est de combiner des mécaniques de jeu, comme la défense de base et l’exploration de Tribes of Midgard, avec les combats dynamiques en vue top-down de Brotato tout en intégrant des systèmes de compétences et des combos élémentaires inspirés de Gunfire Reborn.

Le jeu se déroule dans un monde souterrain où vous incarnez une équipe de nains qui doivent défendre leur forge contre des hordes d’ennemis tout en explorant les cavernes environnantes pour récupérer des ressources et améliorer leurs équipements ou leur base.

La spécificité du jeu que je voudrais vraiment mettre en avant, c’est le mélange entre magie et technologie, avec un mélange d’armes futuristes et des sorts puissants. L’idée étant de pouvoir choisir 3 voies d’améliorations : Technologique, Magique ou un mélange des deux.

Technologie utilisée

Pour ce projet, j’ai décidé de passer du moteur Unity, que je maîtrise bien, au moteur Godot. Ce choix s’est basé sur plusieurs critères :

  • Récents déboire d’Unity
    • L’histoire du changement de modèle avec la taxe à la copie de jeu sortie de nulle part en 2023
    • Les nouveautés annoncées des années en avance comme si elles étaient quasiment prêtes mais qui peinent à sortir
    • Les licenciements en série qui ne donnent pas forcément confiance pour la suite du moteur.
  • Avantages de Godot
    • Se lancer sur un nouveau moteur va permettre d’amener du changement et une motivation supplémentaire
    • Jeu en 2D bien adapté à Godot
    • Moteur complètement gratuit et pas de risque de devenir payant d’un coup
    • Possède un composant de navigation pour de la 2D (ce que Unreal ne propose pas par exemple. Oui j’avais aussi comparé avec Unreal 😉 )

Assets Visuels

C’est ici que va être mon vrai défi. Comment donner un aspect visuel intéressant au jeu ainsi qu’une véritable atmosphère alors que je ne suis pas Designer de base.

Dans un premier temps, j’ai décidé de m’en remettre à des packs d’assets que j’avais achetés il y a quelques temps ainsi qu’a de la génération via l’IA.

Ainsi le logo du jeu a été généré par Dall-e (via ChatGpt) puis retouché.