The Signal : Stranded on Sirenis est le jeu sur lequel j’ai travaillé lorsque j’étais employé chez Goose Byte Studios. J’ai travaillé sur le projet pendant environ 6 mois.

Le développement du jeu n’a pas été fini mais une démo est présentement disponible sur Steam

Mon rôle dans le projet

Lorsque je suis arrivé chez Goose Byte, la direction générale du projet venait tout juste de subir des changements drastiques. Certains aspects du jeu étaient à refaire à partir de zéro ou presque, incluant les systèmes de personnages IA.

J’ai donc été tâché de développer de nouveaux systèmes pour l’utilisation de personnages IA, puis par la suite, d’intégrer et assurer le bon fonctionnement de ces personnages en jeu.

J’étais essentiellement responsable de tout ce qui touchait aux personnages non-joueur côté technique dans le projet.

Création de systèmes pour les personnages IA

J’ai été chargé de concevoir, prototyper et implémenter la plupart des systèmes liés aux personnages IA dans le jeu. Voici un aperçu des principaux systèmes sur lesquels j’ai travaillé.

Arbres de comportements et archétypes de personnages

La plupart des créatures et des ennemis du jeu (à l’exception de quelques boss uniques) utilisaient un même arbre de comportements général.

Cet arbre permettait à tous les personnages d’avoir des comportements facilement interchangeables et gérait toutes les actions de base telles que se déplacer, patrouiller, attaquer, s’enfuir, et bien plus encore.

Chaque personnage avait un archétype général qui dictait la manière dont il réagissait face au joueur et aux autres personnages. Par exemple, les personnages agressifs attaquaient toujours leurs ennemis dès qu’ils les détectaient, tandis que les personnages peureux s’enfuyaient systématiquement. Des paramètres supplémentaires pouvaient ensuite être définis pour permettre des comportements plus spécifiques. Par exemple, un personnage pouvait être configuré pour ne s’enfuir que lorsque sa santé tombait en dessous d’un certain seuil ou seulement s’il y avait un certain nombre de personnages ennemis à proximité. À l’inverse, un personnage pouvait aussi être configuré pour n’attaquer que s’il y avait suffisamment de personnages alliés autour de lui.

Ces paramètres ont été conçus pour être facilement modifiés, ce qui nous permettais de rapidement prototyper de nouveaux types de créatures et tester différents comportements.

Système d’équipes

J’ai créé un système qui nous permettait de facilement définir à quelles équipes appartenait chaque personnage et comment ils devaient réagir face aux personnages d’autres équipes.

Ce système a été conçu de manière à ce que les équipes puissent être définies de manière aussi large ou restrictive que nécessaire à l’aide d’une hiérarchie de gameplay tags. Par exemple, une créature spécifique pouvait être classée sous « Faune  -> Mammifères -> Proies », et une autre sous « Faune -> Oiseaux -> Prédateurs », ce qui signifie qu’une autre créature pouvait être configurée soit pour considérer toute créature classée dans « Faune » comme ennemie, soit pour plus spécifiquement considérer uniquement que les mammifères ou les proies comme ennemis.

Example du système de priorisation de cibles en action.

Comme les araignées ont une priorité plus élevée que le joueur, le drone tentera d’abord de toutes les éliminer avant de s’attaquer au joueur.

Capacités de personnages et sélection d’attaques

Grâce au Gameplay Ability System d’Unreal Engine, les créatures du jeu pouvaient se faire attribuer et utiliser une variété de capacités.

Les personnages pouvaient disposer de plusieurs attaques différentes. Lorsqu’ils passaient en état d’attaque, ils pouvaient choisir l’attaque la plus pertinente à exécuter en fonction de divers paramètres, incluant par exemple la distance envers leur cible, le temps écoulé depuis la dernière utilisation de l’attaque ou même simplement un pourcentage de chance aléatoire.

Certains de ces personnages pouvaient également utiliser d’autres capacités telles que qu’esquiver, se téléporter, se rendre invisible, se guérir soi-même ou ses alliés, et bien plus encore.

Intégrations des ennemis et autres personnages

J’étais généralement responsable d’intégrer les créatures dans le jeu et de programmer leur comportement. J’ai travaillé étroitement avec les artistes et les designers sonores pour intégrer correctement leurs modèle, leurs animations et leur audio, ainsi qu’avec les designers gameplay afin que toutes les créatures agissent selon leurs besoins et soient bien balancés.

J’ai exposé plusieurs paramètres dans des tables de données afin que moi et les autres designers puissions facilement modifier les valeurs des personnages. Ces valeurs incluaient par exemple le nombre de vie, la vitesse de déplacement, l’archétype de comportement, le type d’attaque et bien plus encore.

Situations de combat

J’ai aussi été responsable de créer des outils qui permettraient aux concepteurs de niveaux d’avoir des options sur quand et comment faire apparaître les ennemis dans le jeu afin qu’ils puissent créer des situations de combat intéressantes.

Parmis les options que j’ai mis à leur disposition, ils pouvaient entre autres faire apparaître différentes vagues d’ennemis, placer des nids pour faire apparaître des ennemis régulièrement, créer des groupes qui patrouillent certaines zones ou simplement placer des créatures directement dans les niveaux. J’ai aussi créé des outils pour leurs permettre de définir des chemins de patrouille et des zones pour se promener aléatoirement.

Mes apprentissages

Avec The Signal: Stranded on Sirenis, j’ai pu grandement approfondir mes connaissances techniques avec Unreal Engine, surtout en terme d’implémentation de personnages IA. J’en ai appris beaucoup plus sur les Behaviour Trees, la navigation IA et le Gameplay Ability System entre autres.

Puisque la majorité du projet avait été codée en C++, j’ai souvent dû moi aussi coder mes fonctionnalités directement en C++ plutôt que d’utiliser les Blueprints, avec lesquels j’étais bien plus familier. J’avais déjà un peu programmé dans ce langage auparavant, mais jamais de manière aussi approfondie. Travailler sur ce projet m’a poussé à sortir de ma zone de confort et à acquérir beaucoup plus d’expérience avec la programmation en C++.

De plus, en travaillant chez Goose Byte, j’ai pu faire ma première expérience de ce qu’est travailler sur une vrais production de jeu au sein d’un vrais studio indépendant, avec tout ce que cela implique. Incluant par exemple les milestones, le marketing, les attentes des éditeurs, les Jiras, les délais stricts, etc…

Logiciels et outils utilisés

• Unreal Engine 5
• Confluence
• Jira
• Miro
• Github Desktop
• Discord

All Abug! Est un projet étudiant réalisé en environ 6 mois dans le cadre du projet final du baccalauréat en création de jeux vidéos de l’Université du Québec en Abitibi-Témiscamingue.

All Abug! Est un jeu d’aventure à la première personne situé dans un monde d’insectes, où vous incarnez un lézard nommé Noé.

Noé possède une très longue langue qui lui sert de mécanique principale. Il peut l’utiliser pour détruire des obstacles, récupérer des ressources au loin, combattre les ennemis et même s’en servir comme grapin.

Noé est aussi accompagné d’une chenille géante qu’il utilise comme moyen de transport, un peu à la manière d’un train. Tout au long de l’aventure, il devra gérer cette chenille-train et s’assurer qu’elle et ses passagers puissent se rendre à leur destination, tout en la gardant en bonne santé et en l’écartant des dangers et des obstacles sur sa route.

Au début de ce projet, la classe était séparée en 8 équipes qui devaient chacun proposer un projet différent. Au fur et à mesure que la session avançait, des projets se faisaient couper et les membres de ces équipes se faisaient redistribuer dans les projets restants, jusqu’à ce qu’il ne reste que 2 projets finaux. Il était donc important de ne pas trop nous attacher à nos idées, et d’être toujours prêts à accueillir de nouveaux membres ou intégrer de nouvelles équipes.

Pour ma part, j’ai eu la chance d’être dans l’équipe originale d’All Abug!, ce qui veux dire que j’ai pu participer à ce projet du début de la conception jusqu’à la fin de la production.

Mon rôle dans le projet

Étant le lead de l’équipe technique et l’un des quelques programmeurs sur ce projet, j’ai eu l’occasion de toucher à presque tous les systèmes du jeu d’une façon ou d’une autre au fil du développement.

Voici cependant les éléments principaux sur lesquels j’ai travaillé :

Ennemis

Les ennemis représentait un assez gros risque puisque personne dans l’équipe n’avait eu d’expérience en programmation IA dans Unreal Engine auparavant. Au final, l’implémentation des ennemis dans le jeu a été ma responsabilité et est probablement ce sur quoi j’ai passé le plus de temps au cours du développement.

J’ai utilisé de la documentation et des tutoriels en ligne afin d’apprendre les bases nécéssaires pour l’utilisation de Behaviour Trees. J’ai aussi travaillé étroitement avec les artistes pour l’intégration de modèles et animations de personnages.

Trois types d’ennemis sont présents dans le jeu, les fourmis, les papillons de nuit et les moustiques, tous avec une apparence et un comportement différent.

Les moustiques en particulier ont été un réel défi pour moi. Puisqu’ils se déplaçaient en volant et non en marchant, ils ne pouvaient pas utiliser la navigation IA simplifiée d’Unreal Engine pour se déplacer, j’ai donc eu à créer ma propre logique pour leur déplacement et positionnement.

Options de débogage

Système de dialogue

J’ai créé un système permettant aux concepteurs narratifs de facilement déclencher des lignes de dialogues et des conversations entre les personnages pouvant être déclenché n’importe où à travers le jeu.

Ceux-ci pouvaient  ajouter différents déclencheurs et choisir quelle ligne de dialogue serait dite par quel personnage à quel moment comme par exemple, lorsque le personnage atteint un certain lieu ou que le joueur effectue certaines actions.

Je me suis aussi assuré d’y ajouter un système de priorité afin que les personnages ne puissent pas parler l’un par dessus l’autre et que les dialogues plus importants à l’histoire ne puissent pas être coupés par les dialogues aléatoires.

Exemple d’un One Pager que j’ai fait pour illustrer au reste de l’équipe ma proposition pour le fonctionnement de la santé de la chenille.

Mes apprentissages

All Abug! Est un projet où j’ai appris beaucoup de choses, autant en terme de compétences technique qu’en gestion de projet.

C’était le premier projet auquel j’ai participé avec un rôle de lead, j’ai donc pu apprendre à gérer une petite équipe, discuter de la direction du projet avec les autres leads, créer et assigner des tâches et m’assurer que les membres de mon équipe avaient toujours une quantité raisonnable de travail qui leur était assignée.

J’ai aussi pu agrandir mes compétences techniques avec Unreal Engine 5. Puisque c’était pour moi la première fois que je programmais des personnages IA avec cet engin, j’ai pu en apprendre beaucoup sur les Behaviour Trees et la navigation IA, ainsi que sur l’intégration et l’implémentation de modèles et animations de personnages.

J’ai aussi pu en apprendre plus sur d’autres fonctionnalités de l’engin telles que les outils d’optimisation ou encore la gestion de données, à l’aide de data tables et data assets.

Logiciels et outils utilisés

• Unreal Engine 5
• Notion
• Miro
• Perforce (avec P4V)
• Discord