Behaviour Tree
Adaptation de : http://www.gamasutra.com/blogs/ChrisSimpson/20140717/221339/Behavior_trees_for_AI_How_they_work.php
Un Behavior Tree est arbre de nœuds ayant une structure hiérarchisée qui contrôle la prise de décision de l’IA. À l’extrémité de l’arbre, les feuilles sont les actions qui contrôlent l’IA et les branches sont formées par différents types de nœuds qui contrôlent le déplacement optimal le long du Behavior tree .
Ce système permet une grande flexibilité, car il est facile d’ajouter des feuilles et des branches à un arbre existant.
Un Behavior Tree est composé de différents types de nœuds qui peuvent posséder trois états : Succès, Échec ou En marche.
Les deux premiers informent leur parent que leur opération est un succès ou un échec. En marche signifie que le succès ou l’échec de la tâche n’a pas encore été déterminé. Il est important de stocker l’état des nœuds, afin de ne pas retraverser l’ensemble de l’arbre à chaque frame.
##Composite
Un nœud composite est un nœud qui peut avoir un ou plusieurs enfants. Ce nœud traite ses enfants en séquence et retourne Succès ou Echec à son parent selon l’échec ou le succès de ses enfants.
On retrouve principalement deux types de nœuds composites : La séquence et le sélecteur.
###La séquence :
Une séquence visite chaque enfant dans un ordre précis. Si un seul enfant échoue, la séquence retourne Échec et si tous les enfants sont des succès, alors la séquence retourne un Succès. Les séquences permettent de réaliser une liste d’action dans un ordre précis ou de tester une liste de conditions avant de réaliser une action précise.
Par exemple,
Pour réaliser une série d’actions dans un ordre précis :
Pour tester des conditions :
###Le sélecteur :
Un sélecteur visite chaque enfant dans un ordre précis. Le sélecteur va retourner Succès dès qu’un enfant est un succès et ne pas évaluer le reste de la liste.
Ces deux outils permettent d’évaluer différents chemins d’actions dans un ordre de priorité du plus favorable au moins favorable et de retourner Succès.
##Décorateurs :
Un décorateur possède seulement un enfant. Sa fonction est de transformer le résultat qu’il reçoit de son enfant, de tuer l’enfant ou de répéter le processus de l’enfant.
###L’inverseur :
Il inverse le résultat de son enfant, donc Succès devient Échec et vice-versa.
###Le victorieux :
Il retourne toujours Succès, qu'importe le résultat de son enfant.
###Le répéteur :
Il va répéter le noeud de son enfant chaque fois qu'il retourne un résultat. On peut aussi utiliser ce décorateur pour répéter l'action de l'enfant un nombre de cycles déterminé.
###Le répéteur jusqu'à l'échec :
Comme un répéteur, mais il arrête lorsque son enfant retourne Échec.
##Les feuilles
Elles sont les effets qui affectent le robot ou les actions que celui-ci doit réaliser. Une feuille ne peut pas posséder d'enfant.
Les tâches doivent obligatoirement hériter de la classe LeafTask, qui elle hérite de la classe Task. La classe LeafTask appelle le TaskController et l'Info-Manager.
Chaque tâche doit posséder quatre fonctions :
####start() :
Début de la tâche
###check_condition() : Utilisée pour vérifier si la tâche respecte les conditions nécessaires à son exécution.
####exec() : Exécution de la tâche. Il est nécessaire de spécifier, selon les conditions, si la tâche est un succès (task_controller.finish_with_success() ) ou un échec ( task_controller.finish_with_failure() ).
####end() :
Fin de la tâche
###Exemple :
##Créer et exécuter un BehaviorTree :
###Création d'un BehaviorTree :
Pour créer un behaviorTree, il faut tout d'abord créer les différents Sélecteur et Séquences de notre arbre. Puis, il faut créer un TaskController pour notre Séquence/Sélecteur principal. Finalement, il suffit d'ajouter les sous-tâches (feuilles) à nos Séquences/Sélecteurs et de construire l'arbre en ajoutant ces éléments dans l'ordre voulu. Voir exemple pour voir une simple implémentation d'une Séquence contenant un Sélecteur contenant deux feuilles et une Séquence de deux feuilles.
###Exécution du BehaviorTree :
Pour exécuter le behaviortree, il faut commencer (task.start()) la tâche principale, puis l'exécuter jusqu'à ce qu'elle soit achever (done). Finalement, on doit la terminer (task.end()).
###Exemple :
