Pour mon projet actuel, j'ai implémenté un système basé sur des composants / entités , suivant essentiellement la plupart des meilleures pratiques qui existent dans ce domaine plutôt indéfini .
J'ai donc obtenu des entités (légèrement étendues) , qui sont essentiellement un int
ID, un nom lisible par l'homme, un std::map
des composants et un long
"indicateur de type" qui est utilisé pour montrer quels composants sont présents (j'ai une puissance de deux enum
pour tous les composants types et chaque fois qu'un composant est ajouté à l'entité, je modifie automatiquement cette longue via des opérations au niveau du bit, comparer cette réponse ).
Ensuite, il y a les composants , également assez simples: l' int
ID, enum
comme type de composant, le pointeur d'entité parent et une std::map
de toutes les propriétés de ce composant.
Enfin, certains systèmes / gestionnaires qui gèrent le traitement logique réel. Ils vérifient d'abord si l'entité actuellement traitée a un long
"indicateur de type" correspondant = tous les composants nécessaires pour ce système sont présents. Il accède ensuite à certaines propriétés si nécessaire et appelle directement certaines fonctions dans le composant respectif ou envoie des messages (via un répartiteur de messages).
Conclusion: Jusqu'à présent, un système basé sur des composants / entités plutôt standard basé sur des événements combiné à une approche basée sur les données (comparer, les composants n'ont pas de variables de données codées en dur, mais plutôt une carte générique, comme (certains) composants / Les archétypes de composants seront ensuite lus à partir de fichiers avec la possibilité d'ajouter des données supplémentaires, qui ne font pas partie du code de composant réel.
Maintenant, je voudrais également introduire des arbres de comportement (basés sur AiGameDev BTSK ) dans ce projet, mais je ne sais pas si et comment ils doivent être liés aux composants déjà existants ou comment intégrer ces conceptions en général.
Plusieurs idées / points / questions connexes me viennent à l'esprit:
Mes BT seront lus à partir de fichiers (à nouveau). J'ai actuellement du mal à voir comment je ferais au mieux la connexion entre un
BT Action
dans cet arbre et le codage réel dans mon application. Dois-je créer une sorte de mappage entre les noms d'actions utilisés dans les fichiers BT et un pointeur de fonction vers l'implémentation logique réelle? Quelle est l'approche habituelle pour résoudre ce problème?Je suppose que je devrai créer des BT pour tous mes différents
Entity
types (donc pour chaque combinaison de composants de logique de jeu / IA, comme indiqué par mon long "indicateur de type" mentionné plusieurs fois). Par conséquent, il n'est pas logique de mettre lesBT Action
implémentations dans les composants, car de nombreux composants seront probablement impliqués par action, n'est-ce pas?La
BT Action
logique devrait-elle donc reposer sur un / plusieurs systèmes séparés (vers les méthodes desquelles la carte de l'idée n ° 1 pointe)? Le système vérifierait alors par monlong
"indicateur de type" si leEntity
pour lequel le BT est actuellement vérifié et qui a été invité à exécuter une certaine action (= méthode dans le système) est réellement autorisé à le faire (= a les composants nécessaires). Mais alors, sinon (parce que par exemple le créateur de BT a négligé une situation spécifique, où un composant nécessaire pourrait ne plus être attaché à l'entité au moment de l'exécution), rien ne se passerait.
Des questions:
- Existe-t-il des concepts éprouvés pour ce type d'intégration?
- Quelle est votre opinion sur mes 3 points ci-dessus?
- Y a-t-il d'autres choses qui me viennent à l'esprit, concernant également ma conception basée sur les composants / entités en général?