![[Unreal Engine] AI Perception System](https://itamde.com/media/2023/04/unreal-engine-blackboard.jpg "[Unreal Engine] AI Perception System")
Dans l’univers du développement de jeux vidéo, programmer des personnages non-joueurs convaincants et réactifs a longtemps représenté l’un des défis les plus ardus et les plus techniques. Les approches traditionnelles basées sur des machines à états rigides ou des scripts interminables produisaient des comportements prévisibles qui brisaient rapidement l’illusion d’intelligence. Le Behavior Tree dans Unreal Engine bouleverse cette équation en offrant une approche visuelle, modulaire et infiniment plus flexible qui transforme la création d’intelligences artificielles sophistiquées en un processus accessible et intuitif.
Comprendre l’architecture fondamentale du Behavior Tree
Le Behavior Tree, ou arbre de comportement, est un système de l’Unreal Engine destiné à la programmation de l’Intelligence Artificielle des personnages. Cette définition technique masque la révolution conceptuelle que représentent les Behavior Trees dans la façon dont nous pensons et construisons les comportements d’IA. Plutôt que de concevoir l’IA comme un ensemble d’instructions séquentielles ou comme une machine à états avec des transitions explicites, le Behavior Tree modélise la prise de décision comme une hiérarchie de choix évaluée dynamiquement.
Il s’agit d’un graphique visuel en arborescence qui permet de définir le comportement de l’IA en fonction de différentes actions possibles et des conditions qui doivent être remplies pour déclencher ces actions. Cette représentation visuelle transforme la logique abstraite de prise de décision en un diagramme concret où les développeurs voient littéralement le flux de décisions se dérouler de gauche à droite à travers les branches de l’arbre.
L’exécution d’un Behavior Tree commence toujours à la racine et progresse vers les feuilles en évaluant les nœuds rencontrés. Cette traversée de l’arbre se répète continuellement, généralement plusieurs fois par seconde, permettant au personnage de réévaluer constamment sa situation et d’adapter son comportement aux changements de son environnement. Cette réévaluation continue crée une réactivité qui fait paraître le personnage véritablement conscient et adaptatif.
La métaphore de l’arbre capture parfaitement la structure hiérarchique où des décisions de haut niveau se décomposent en choix plus spécifiques qui se raffinent encore jusqu’aux actions concrètes exécutées par le personnage. Cette décomposition naturelle reflète comment nous décomposons mentalement les problèmes complexes en sous-problèmes plus gérables, rendant l’architecture intuitive même pour ceux qui découvrent le concept.
Les différents types de nœuds orchestrent la logique décisionnelle
Le Behavior Tree est composé de différents types de nœuds, tels que les nœuds de condition, les nœuds de sélection, les nœuds de séquence et les nœuds de tâche. Chaque type de nœud joue un rôle spécifique dans l’orchestration du comportement global, et leur combinaison créative permet de construire des logiques décisionnelles arbitrairement complexes.
Les nœuds de sélection, appelés Selector, évaluent leurs enfants de gauche à droite et réussissent dès que le premier enfant réussit. Cette logique « ou » permet d’exprimer des alternatives comportementales où le personnage essaie différentes approches jusqu’à en trouver une qui fonctionne. Un ennemi pourrait avoir un Selector avec comme enfants « AttaquerAuCorpsÀCorps », « AttaquerÀDistance », puis « Fuir », essayant chaque option dans l’ordre jusqu’à en trouver une appropriée à la situation.
Les nœuds de séquence, appelés Sequence, fonctionnent inversement en exécutant leurs enfants de gauche à droite et échouant dès que le premier enfant échoue. Cette logique « et » exprime des séquences d’actions qui doivent toutes réussir. Un comportement de patrouille pourrait utiliser une séquence : « SeDéplacerVersWaypoint », puis « AttendreDuréeDéterminée », puis « PasserAuWaypointSuivant ». Si n’importe quelle étape échoue, la séquence entière échoue.
Les nœuds de tâche représentent les feuilles de l’arbre et effectuent les actions concrètes comme se déplacer, attaquer, jouer une animation, ou modifier des variables. Ces tâches constituent le vocabulaire d’actions que votre IA peut accomplir. Créer des tâches réutilisables et bien conçues facilite énormément la construction de Behavior Trees complexes puisque vous composez simplement ces briques fondamentales.
Les Decorators attachés aux nœuds ajoutent des conditions ou modifient le comportement de l’exécution. Un Decorator « Blackboard Based Condition » vérifie une valeur avant d’autoriser l’exécution de la branche qu’il garde. Un Decorator « Cooldown » empêche la réexécution d’une branche avant qu’un délai ne se soit écoulé. Ces modificateurs enrichissent considérablement l’expressivité du système sans complexifier la structure de base.
L’intégration avec le Blackboard fournit la mémoire contextuelle
Les nœuds sont connectés les uns aux autres pour créer une arborescence de décision qui permet de déterminer les actions que doit effectuer l’IA en fonction de la situation dans laquelle elle se trouve. Cette capacité de réaction situationnelle repose fondamentalement sur l’intégration étroite entre le Behavior Tree et le Blackboard, le système de mémoire qui stocke les informations contextuelles.
Le Blackboard contient toutes les variables que le Behavior Tree consulte pour prendre ses décisions. Une variable « CibleActuelle » contient la référence vers l’ennemi que le personnage poursuit. Une variable « NiveauSanté » indique l’état physique du personnage. Une variable « EstEnAlerte » signale si le personnage a détecté une menace. Toutes ces informations informent les choix effectués lors de la traversée de l’arbre.
Les Decorators lisent constamment le Blackboard pour évaluer leurs conditions. Un comportement d’attaque pourrait être gardé par un Decorator vérifiant que « CibleActuelle » contient une référence valide. Sans cible, cette branche ne s’exécute jamais, forçant le Selector parent à considérer d’autres alternatives. Cette dépendance dynamique aux données du Blackboard crée un couplage flexible entre perception et action.
Les tâches écrivent dans le Blackboard pour communiquer des résultats ou mettre à jour l’état du personnage. Une tâche de recherche qui localise un objet intéressant pourrait stocker sa position dans le Blackboard, la rendant immédiatement disponible pour d’autres parties du Behavior Tree. Cette capacité de modification du contexte permet aux comportements de construire progressivement des connaissances et de coordonner leurs actions.
Les services maintiennent les informations contextuelles à jour
Les Services représentent un type spécial de nœud qui s’exécute périodiquement pendant que leur branche parent reste active. Ces mises à jour en arrière-plan maintiennent le Blackboard synchronisé avec la réalité changeante sans que chaque tâche doive gérer manuellement ses propres actualisations.
Un Service typique pourrait mettre à jour la distance vers la cible toutes les demi-secondes. Calculer cette distance une fois et la stocker dans le Blackboard évite que dix tâches différentes recalculent indépendamment la même valeur. Cette factorisation améliore à la fois les performances et la cohérence des décisions basées sur cette information.
Les Services peuvent également implémenter des comportements opportunistes comme scanner l’environnement pour des menaces potentielles pendant que le personnage effectue d’autres actions. Cette détection en arrière-plan permet d’interrompre le comportement actuel si quelque chose d’urgent survient, créant une réactivité qui imite l’attention divisée des êtres conscients.
La périodicité des Services offre un contrôle fin sur le compromis entre réactivité et coût de calcul. Un Service critique pourrait s’exécuter plusieurs fois par seconde tandis qu’un Service moins urgent ne s’exécute qu’une fois toutes les quelques secondes. Cette hiérarchie de priorités concentre les ressources de calcul là où elles comptent le plus.
Les avantages sur les approches traditionnelles se révèlent rapidement
Le Behavior Tree permet aux développeurs de créer facilement des comportements complexes pour leurs personnages, en utilisant une approche visuelle et modulaire. Cette facilité relative comparée aux machines à états finies ou aux scripts procéduraux ne signifie pas que les Behavior Trees sont simplistes, mais plutôt qu’ils rendent la complexité gérable.
Les machines à états souffrent d’une explosion combinatoire du nombre de transitions nécessaires. Avec cinq états, vous pourriez avoir besoin de vingt transitions possibles. Avec dix états, ce nombre explose à quatre-vingt-dix transitions potentielles. Maintenir et déboguer ce réseau de transitions devient rapidement cauchemardesque. Les Behavior Trees évitent ce problème en décomposant hiérarchiquement les décisions, chaque niveau gérant un sous-ensemble du problème.
Les scripts procéduraux offrent une flexibilité totale mais au prix d’une maintenabilité désastreuse. Un script de mille lignes définissant le comportement d’un boss de jeu devient incompréhensible pour quiconque ne l’a pas écrit, y compris souvent son auteur original quelques mois plus tard. La structure visuelle du Behavior Tree rend la logique immédiatement apparente, facilitant énormément la collaboration et la maintenance.
La modularité des Behavior Trees encourage la réutilisation. Une branche gérant le comportement de fuite peut être copiée entre différents types d’ennemis et ajustée au besoin. Des bibliothèques de comportements communs émergent naturellement, accélérant le développement de nouveaux personnages qui combinent et adaptent ces composants préexistants.
Les cas d’usage pratiques démontrent la versatilité du système
Il est largement utilisé dans l’Unreal Engine pour créer des comportements d’IA pour les jeux, les simulations, la réalité virtuelle et la réalité augmentée. Cette adoption généralisée témoigne de la versatilité fondamentale de l’architecture Behavior Tree qui s’applique à pratiquement n’importe quel domaine nécessitant des agents autonomes.
Dans les jeux d’action, les ennemis utilisent des Behavior Trees pour équilibrer agressivité et survie. Un Selector de haut niveau choisit entre « AttaquerJoueur » et « Survivre ». La branche d’attaque contient différentes tactiques selon la distance et les armes disponibles. La branche de survie gère la fuite, la recherche de couverture, et l’appel de renforts. Cette structure reflète intuitivement comment un combattant réel pèse ses options.
Les personnages alliés et les compagnons s’appuient sur des Behavior Trees pour équilibrer leur utilité combative et leur besoin de ne pas gêner le joueur. Un compagnon doit rester suffisamment proche pour aider mais pas au point de bloquer constamment le chemin. Son Behavior Tree jongle entre « AiderAuCombat », « SuivreJoueur », et « ReculerSiTropProche », créant un équilibre dynamique qui s’adapte aux circonstances.
Les civils dans les jeux en monde ouvert utilisent des Behavior Trees pour simuler des vies quotidiennes crédibles. Un Selector choisit entre différentes activités selon l’heure et la situation : travailler, manger, socialiser, se divertir, ou dormir. Chaque activité se décompose en séquences d’actions spécifiques. L’injection d’événements exceptionnels comme des crimes ou des accidents interrompt ces routines, créant une impression de monde vivant.
Les simulations de formation utilisent des Behavior Trees pour créer des scénarios réalistes. Des agents simulant des patients médicaux, des clients difficiles, ou des situations d’urgence doivent réagir de manière crédible aux actions de l’apprenant. Les Behavior Trees orchestrent ces réactions complexes d’une manière qui reste cohérente et pédagogiquement utile.
Les patterns de conception émergent de l’usage répété
Certaines structures de Behavior Tree réapparaissent fréquemment car elles résolvent élégamment des problèmes communs. Reconnaître et appliquer ces patterns accélère le développement et améliore la qualité des comportements créés.
Le pattern de priorisation utilise un Selector avec des branches ordonnées de la plus importante à la moins importante. Les comportements critiques comme fuir un danger mortel apparaissent en premier. Les comportements opportunistes comme ramasser des objets intéressants apparaissent vers la fin. Cette structure garantit que les décisions vitales prennent toujours priorité sur les actions secondaires.
Le pattern de tentative multiple emploie un Selector avec plusieurs approches pour accomplir le même objectif. Essayer d’ouvrir une porte pourrait inclure « UtiliserClé », « CrochetageSerrure », « EnfoncerPorte », et finalement « ChercherAutreChemin ». Le personnage essaie chaque méthode jusqu’à en trouver une qui fonctionne, créant une adaptabilité qui impressionne le joueur.
Le pattern de machine à états hybride combine un Selector de haut niveau choisissant entre différents états comportementaux avec des Sequences implémentant chaque état. Cette structure capture les avantages des machines à états, la clarté de séparation entre modes comportementaux distincts, tout en évitant l’explosion combinatoire des transitions grâce à la structure hiérarchique.
Le pattern de comportement interruptible utilise des Decorators qui observent le Blackboard et interrompent l’exécution si certaines conditions deviennent vraies. Un personnage engagé dans une activité paisible peut immédiatement basculer en mode combat si un Decorator détecte l’apparition d’une menace. Cette réactivité évite que les personnages terminent stupidement des actions devenues dangereuses ou inappropriées.
Le débogage visuel révèle l’exécution en temps réel
Unreal Engine fournit des outils de visualisation exceptionnels qui montrent exactement quelle branche du Behavior Tree s’exécute actuellement, quels nœuds ont réussi ou échoué récemment, et comment le flux d’exécution progresse à travers l’arbre. Cette transparence transforme le débogage d’un processus frustrant en une investigation visuelle intuitive.
Les nœuds actifs s’affichent en surbrillance pendant que le jeu s’exécute, créant une animation en temps réel de la pensée du personnage. Regarder cette visualisation révèle immédiatement si le comportement observé correspond à ce que vous aviez conçu. Un personnage qui se comporte bizarrement montre souvent un chemin d’exécution inattendu à travers l’arbre.
Les historiques d’exécution montrent les nœuds récemment traversés et leurs résultats. Cette mémoire visuelle aide à diagnostiquer des problèmes intermittents où un comportement incorrect se produit brièvement puis disparaît avant que vous puissiez observer l’état en direct. L’historique capture ces moments fugaces pour analyse.
Les points d’arrêt conditionnels permettent de mettre en pause l’exécution lorsque certains nœuds sont atteints ou lorsque certaines variables Blackboard changent. Cette capacité de capturer précisément le moment où quelque chose d’intéressant se produit accélère énormément le processus de compréhension et de correction des comportements défectueux.
Les considérations de performance guident l’optimisation
Bien que les Behavior Trees soient relativement efficaces, leur exécution consomme des cycles de calcul qui s’accumulent avec des centaines de personnages actifs. Les stratégies d’optimisation deviennent essentielles pour maintenir des framerates acceptables dans les scènes peuplées.
Limiter la fréquence de mise à jour des Behavior Trees économise des ressources substantielles. Un personnage distant ou hors écran peut mettre à jour son comportement seulement une fois par seconde au lieu de chaque frame. Cette dégradation gracieuse concentre les mises à jour fréquentes sur les personnages que le joueur observe directement.
Simplifier les Behavior Trees pour les personnages moins importants maintient une diversité comportementale tout en réduisant les coûts. Un figurant dans une foule peut utiliser un arbre beaucoup plus simple qu’un boss de niveau. Cette hiérarchie de complexité alloue intelligemment le budget de calcul selon l’importance narrative et gameplay de chaque personnage.
Utiliser des Parallel nodes judicieusement permet d’exécuter plusieurs branches simultanément mais augmente la complexité et le coût. Réserver le parallélisme pour les situations où il apporte une valeur réelle plutôt que de l’utiliser par défaut maintient les performances sous contrôle.
Factoriser les calculs coûteux dans des Services qui s’exécutent périodiquement plutôt que de les répéter dans chaque tâche évite la duplication de travail. Un calcul de distance effectué une fois par un Service et stocké dans le Blackboard sert toutes les tâches qui en ont besoin sans recalcul.
L’extensibilité permet des systèmes comportementaux sophistiqués
Les développeurs peuvent créer des types de nœuds personnalisés pour étendre les capacités de base des Behavior Trees. Cette extensibilité permet d’adapter le système aux besoins spécifiques de chaque projet sans être limité aux nœuds fournis par défaut.
Les tâches personnalisées encapsulent des actions complexes spécifiques au jeu. Une tâche « NégocierAvecMarchand » pourrait gérer toute la logique d’interaction commerciale, cachant cette complexité derrière un nœud simple et réutilisable. Cette abstraction maintient les Behavior Trees lisibles même lorsqu’ils orchestrent des comportements sophistiqués.
Les Decorators personnalisés implémentent des conditions logiques uniques au contexte du jeu. Un Decorator « EstDansZoneSûre » pourrait vérifier la position du personnage contre des zones définies dans le niveau. Encapsuler cette logique dans un Decorator nommé clairement rend les Behavior Trees auto-documentés.
Les Services personnalisés effectuent des mises à jour périodiques adaptées aux mécaniques spécifiques. Un Service « GérerFaim » pourrait diminuer progressivement un compteur de satiété et mettre à jour les priorités comportementales en conséquence. Cette encapsulation de systèmes de jeu complexes dans des Services maintient la séparation des responsabilités.
Les nœuds composites personnalisés permettent d’inventer de nouvelles structures de contrôle au-delà des Selectors et Sequences standard. Un nœud « RandomSelector » qui choisit aléatoirement parmi ses enfants plutôt que de les évaluer séquentiellement injecte de l’imprévisibilité qui rend les personnages moins prévisibles.
L’intégration avec les autres systèmes d’IA complète l’écosystème
Les Behavior Trees ne fonctionnent pas en isolation mais s’intègrent profondément avec les autres composants du système d’IA d’Unreal Engine. Cette intégration crée un écosystème cohérent où chaque système joue son rôle spécialisé.
L’AI Perception System détecte les stimuli environnementaux et écrit les résultats dans le Blackboard. Le Behavior Tree réagit alors à ces informations sensorielles sans avoir à interroger directement le système de perception. Cette séparation des responsabilités maintient chaque système focalisé sur sa fonction principale.
Le système de navigation calcule et exécute les déplacements demandés par les tâches du Behavior Tree. Une tâche « SeDéplacerVersPosition » communique simplement la destination désirée au système de navigation qui gère tous les détails du pathfinding et du mouvement. Cette abstraction permet aux Behavior Trees de raisonner à un niveau stratégique sans se soucier des détails de navigation.
Le système d’animation sélectionne et joue les animations appropriées basées sur l’état comportemental actuel. Bien que techniquement séparé, le système d’animation peut lire le Blackboard pour synchroniser les animations avec l’état mental du personnage, créant une cohérence entre pensée et mouvement.
Les Event Dispatchers permettent à des événements de gameplay externes de déclencher des modifications du Blackboard qui influencent alors le Behavior Tree. Cette communication événementielle crée une boucle de feedback où les actions du joueur et les événements du monde affectent organiquement les comportements des personnages.
Les limitations connues orientent les décisions architecturales
Les Behavior Trees ne constituent pas une solution universelle et présentent des limitations qui orientent vers des approches alternatives ou hybrides dans certaines situations. Reconnaître ces limites évite de forcer le système dans des contextes où il ne brille pas.
Les comportements très réactifs qui nécessitent une coordination fine au niveau frame-par-frame peuvent être mieux servis par des systèmes de contrôle plus bas niveau. Un système de combat de combat au corps à corps nécessitant des timings précis de parades et de ripostes pourrait utiliser un système spécialisé plutôt qu’un Behavior Tree.
Les comportements nécessitant une planification à long terme avec de nombreuses étapes interdépendantes peuvent dépasser les capacités naturelles des Behavior Trees. Les systèmes GOAP (Goal-Oriented Action Planning) gèrent mieux la planification multi-étapes où l’ordre des actions doit être déterminé dynamiquement plutôt que prédéfini dans l’arbre.
Les comportements nécessitant un apprentissage adaptatif où l’IA modifie sa stratégie basée sur l’expérience passée dépassent le cadre standard des Behavior Trees. Bien que l’on puisse implémenter des formes rudimentaires d’apprentissage, les systèmes d’apprentissage automatique offrent des capacités beaucoup plus sophistiquées dans ce domaine.
Les comportements émergents complexes résultant d’interactions entre de nombreux agents peuvent être mieux capturés par des systèmes de simulation basés sur des règles locales. Les comportements de foule complexes où chaque individu suit des règles simples mais crée des patterns collectifs sophistiqués ne se cartographient pas naturellement sur des Behavior Trees individuels.
L’apprentissage progressif construit la maîtrise
Les développeurs débutant avec les Behavior Trees bénéficient d’une courbe d’apprentissage relativement douce. Les concepts de base, Selectors et Sequences, sont intuitifs. Construire un premier Behavior Tree simple produisant un comportement observable peut se faire en quelques heures.
Les tutoriels officiels d’Epic Games et l’abondante documentation communautaire accélèrent l’apprentissage. Des exemples de projets montrent des Behavior Trees fonctionnels pour différents types de personnages, fournissant des modèles que les débutants peuvent étudier et adapter. Cette richesse de ressources abaisse significativement la barrière d’entrée.
La pratique révèle progressivement des techniques plus sophistiquées. Comprendre comment structurer efficacement les Decorators, quand utiliser des Services versus des mises à jour dans les tâches, comment factoriser les comportements communs : ces compétences s’affinent avec l’expérience et l’expérimentation.
Les projets personnels permettent d’explorer librement sans contraintes. Créer un projet test dédié à l’expérimentation avec différentes structures de Behavior Tree facilite l’apprentissage sans risquer de casser un projet principal. Cette aire de jeu sûre encourage l’exploration et l’innovation.
L’évolution continue enrichit les capacités du système
Chaque nouvelle version d’Unreal Engine apporte des améliorations et des extensions aux Behavior Trees. Ces évolutions reflètent à la fois les retours de la communauté et l’innovation continue d’Epic Games pour maintenir le système à la pointe.
Les optimisations de performance réduisent progressivement le coût d’exécution des Behavior Trees. Les améliorations de la machine virtuelle, les mises en cache intelligentes, et les algorithmes de traversée optimisés permettent de supporter des populations d’agents toujours plus nombreuses.
Les nouveaux types de nœuds étendent les capacités expressives. Des nœuds de contrôle additionnels, des Decorators plus sophistiqués, et des Services avec de nouvelles capacités élargissent la palette d’outils disponibles sans rompre la compatibilité avec les arbres existants.
L’intégration plus profonde avec d’autres systèmes crée une cohésion croissante de l’écosystème d’IA. Les ponts facilités entre Behavior Trees et systèmes d’animation, de dialogue, de quêtes, et de gameplay éliminent progressivement les frictions qui nécessitaient auparavant du code de liaison manuel.
Les outils de profilage et d’analyse deviennent plus sophistiqués. Des visualisations de performance montrant quels nœuds consomment le plus de temps, des statistiques d’utilisation révélant les branches rarement exécutées, et des suggestions automatiques d’optimisation guident les développeurs vers des améliorations basées sur des données concrètes.
La communauté partage expertise et ressources
L’écosystème autour des Behavior Trees d’Unreal Engine inclut une communauté active qui partage généreusement des connaissances, des templates, et des solutions à des problèmes communs. Cette effervescence communautaire multiplie la valeur du système bien au-delà de ce qu’Epic Games fournit directement.
Les forums et Discord regorgent de discussions techniques où les développeurs exposent leurs défis et reçoivent des conseils d’experts. Cette entraide accélère considérablement la résolution de problèmes qui pourraient autrement bloquer un projet pendant des jours.
Le marketplace d’Unreal Engine propose des Behavior Trees préfabriqués et des packages de nœuds personnalisés couvrant des cas d’usage courants. Ces assets commerciaux permettent d’acquérir instantanément des comportements sophistiqués développés et testés par des professionnels.
Les projets open source sur GitHub exposent des implémentations complètes que les développeurs peuvent étudier, modifier et adapter. Cette transparence du code fournit des exemples concrets de comment résoudre des problèmes complexes plutôt que de simples descriptions théoriques.
Les présentations lors de conférences et les articles techniques approfondis partagent les leçons apprises sur des productions AAA. Ces retours d’expérience de l’industrie révèlent des patterns et des anti-patterns qui ne deviennent apparents que sur des projets à grande échelle.
La maîtrise des Behavior Trees élève la qualité de l’IA
La différence entre une IA fonctionnelle et une IA impressionnante réside largement dans la sophistication et l’élégance de son Behavior Tree. Les personnages qui semblent réellement intelligents, qui surprennent le joueur par leurs réactions imprévisibles mais cohérentes, qui s’adaptent aux stratégies du joueur : tous reposent sur des Behavior Trees soigneusement conçus.
Pour les studios de développement, investir dans l’expertise Behavior Tree paie des dividendes sur le long terme. Cette compétence se transfère entre projets, s’améliore avec la pratique, et produit des actifs réutilisables qui accélèrent chaque nouveau développement.
Les Behavior Trees dans Unreal Engine exemplifient une philosophie de conception où la puissance technique s’allie à l’accessibilité. En transformant la programmation d’IA d’un exercice de code complexe en un processus de conception visuelle, tout en maintenant la profondeur nécessaire pour des comportements véritablement sophistiqués, le système rend la création de personnages intelligents accessible à une audience beaucoup plus large. Cette démocratisation élève le plancher de qualité pour l’IA dans les jeux tout en repoussant simultanément le plafond de ce que les experts peuvent accomplir. Dans un médium où des personnages crédibles et engageants contribuent fondamentalement à l’immersion et au plaisir, maîtriser les Behavior Trees devient une compétence essentielle pour quiconque aspire à créer des expériences de jeu mémorables.
Voila, vous pouvez maintenant briller en soirée …
0 commentaires