Conception d’un moteur de jeu basé sur un composant

Je me suis penché sur la conception du moteur de jeu (en particulier sur les moteurs de jeu 2D, mais également sur les jeux 3D) et je suis intéressé par certaines informations sur la manière de procéder. J’ai entendu dire que de nombreux moteurs évoluent aujourd’hui vers une conception basée sur les composants plutôt que vers la hiérarchie traditionnelle des objects profonds.

Connaissez-vous de bons liens avec des informations sur la façon dont ces types de modèles sont souvent mis en œuvre? J’ai vu évoluer votre hiérarchie , mais je ne peux pas vraiment en trouver plus avec des informations détaillées (la plupart d’entre eux semblent simplement dire «utiliser des composants plutôt qu’une hiérarchie», mais j’ai trouvé qu’il fallait un peu d’effort pour changer de pensée) entre les deux modèles).

Tous les bons liens ou informations à ce sujet seraient appréciés, et même des livres, bien que des liens et des réponses détaillées soient préférables.

Mise à jour 2013-01-07 : Si vous voulez voir un bon mélange de moteur de jeu basé sur des composants avec une approche (à mon avis) supérieure de programmation réactive, jetez un oeil au moteur V-Play . Il intègre très bien la fonctionnalité de liaison de propriétés QMLs QT.

Nous avons fait des recherches sur CBSE dans les jeux de notre université et j’ai collecté du matériel au fil des ans:

CBSE dans la littérature de jeux:

Architecture du moteur de jeu
Game Programming Gems 4: Un système pour le jeu des entités de jeu
Programmation de jeux Gems 5: Gestion d’objects basée sur les composants
Programmation de jeux Gems 5: Une bibliothèque de composants génériques
Programmation de jeux Gems 6: Système de composants d’object de jeu
Développement de jeux orientés object
Architektur des Kerns einer Game-Engine et implémentation en Java (allemand)

Le framework de jeu Elephant est un très bon exemple de moteur de jeu basé sur des composants en C #.

Si vous voulez vraiment savoir quels composants sont lus: Génie logiciel basé sur les composants! Ils définissent un composant comme:

Un composant logiciel est un élément logiciel conforme à un modèle de composant et pouvant être déployé et composé indépendamment sans modification selon une norme de composition.

Un modèle de composant définit des normes d’ interaction et de composition spécifiques . Une implémentation de modèle de composant est l’ensemble dédié d’éléments logiciels exécutables requirejs pour prendre en charge l’exécution de composants conformes au modèle.

Une infrastructure de composants logiciels est un ensemble de composants logiciels interactifs conçus pour garantir qu’un système logiciel ou un sous-système construit à l’aide de ces composants et interfaces répondra à des spécifications de performance clairement définies.

Après 2 ans d’expérience avec CBSE dans les jeux, j’ai pensé que la programmation orientée object était simplement une impasse. Souvenez-vous de mon avertissement lorsque vous regardez vos composants devenir de plus en plus petits, et plus comme des fonctions empaquetées dans des composants avec beaucoup de frais inutiles. Utilisez plutôt la programmation à réactivité fonctionnelle . Jetez également un coup d’œil à mon nouveau billet de blog (qui m’a amené à poser cette question tout en l’écrivant :)) à propos de Pourquoi je suis passé de l’architecture de moteur de jeu basée sur les composants à l’architecture FRP .

CBSE dans les journaux de jeux:

Développement de jeux basé sur les composants – Une solution pour augmenter les coûts et augmenter les délais?
~~Une architecture flexible et évolutive pour les jeux informatiques~~ (404)
Une architecture logicielle pour les jeux
Un cadre générique pour le développement de jeux (WebArchive)
Composition intelligente d’objects de jeu utilisant l’dependency injection

CBSE dans les liens de jeux (sortingés par pertinence):

~~Objets à base de composants Wiki~~ (wiki vide)
Faites évoluer votre hiérarchie
Structure de l’object de jeu: inheritance et agrégation
Un système d’object de jeu piloté par les données (PDF)
Un système d’object de jeu piloté par les données (PPT)
Outil de prototypage à base de composants pour flash
~~Théorie et pratique de l’architecture des composants des jeux~~ (404)
Les systèmes d’entités sont l’avenir des MMO
Forum ogre3d.org: Objets basés sur les composants
gamedev.net: Architecture du système d’entités basées sur des composants externes
gamedev.net: question du système d’entité
Blog entité-système de Brainfold (WebArchive)

Il semble y avoir un manque d’informations sur le sujet. J’ai récemment implémenté ce système et j’ai trouvé un très bon Powerpoint GDC qui expliquait les détails qui sont souvent laissés pour compte. Ce document est ici: Théorie et pratique de l’architecture des composants d’objects de jeu

En plus de ce Powerpoint, il existe de bonnes ressources et divers blogs . PurplePwny a une bonne discussion et des liens vers d’autres ressources. Ugly Baby Studios discute un peu de l’interaction des composants entre eux. Bonne chance!

Bien qu’il ne s’agisse pas d’un didacticiel complet sur la conception des moteurs de jeux, j’ai trouvé que cette page contient de nombreux détails et exemples sur l’utilisation de l’architecture des composants pour les jeux.

Il est open-source et disponible sur http://codeplex.com/elephant

Quelqu’un a fait un exemple de travail du code gpg6, vous pouvez le trouver ici: http://www.unseen-academy.de/componentSystem.html

ou ici: http://www.mcshaffry.com/GameCode/thread.php?threadid=732

Cordialement

Je suis actuellement à la recherche de ce sujet dans les nombreux (BEAUCOUP) sujets sur GameDev.net et j’ai trouvé les deux solutions suivantes pour être de bons candidats sur ce que je développerai pour mon jeu:

Critique mon système d’entités basé sur des composants
Architecture du système d’entités basées sur des composants externes -> Proposition de Lord_Evil

J’ai recherché et mis en œuvre ce dernier semestre pour un cours de développement de jeux. J’espère que cet exemple de code peut vous orienter dans la bonne direction.

class Entity { public: Entity(const unsigned int id, const std::ssortingng& enttype); ~Entity(); //Component Interface const Component* GetComponent(const std::ssortingng& family) const; void SetComponent(Component* newComp); void RemoveComponent(const std::ssortingng& family); void ClearComponents(); //Property Interface bool HasProperty(const std::ssortingng& propName) const; template T& GetPropertyDataPtr(const std::ssortingng& propName); template const T& GetPropertyDataPtr(const std::ssortingng& propName) const; //Entity Interface const unsigned int GetID() const; void Update(float dt); private: void RemoveProperty(const std::ssortingng& propName); void ClearProperties(); template void AddProperty(const std::ssortingng& propName); template Property* GetProperty(const std::ssortingng& propName); template const Property* GetProperty(const std::ssortingng& propName) const; unsigned int m_Id; std::map m_Properties; std::map m_Components; };

Les composants spécifient le comportement et opèrent sur les propriétés. Les propriétés sont partagées entre tous les composants par une référence et obtiennent des mises à jour gratuitement. Cela signifie qu’il n’y a pas de gros frais pour le passage des messages. S’il y a des questions, je vais essayer de répondre du mieux que je peux.

Dans ce contexte, les composants me semblent être des parties d’exécution isolées d’un moteur pouvant s’exécuter simultanément avec d’autres composants. Si c’est la motivation, alors vous pourriez vouloir regarder le modèle d’acteur et les systèmes qui l’utilisent.

Artcle intéressant …

J’ai fait une recherche rapide sur Google et je n’ai rien trouvé, mais vous voudrez peut-être vérifier certains commentaires – beaucoup de personnes semblent avoir essayé d’implémenter une démo de composants simples, vous devriez peut-être jeter un coup d’œil à certains commentaires. du leur pour l’inspiration:

http://www.unseen-academy.de/componentSystem.html
http://www.mcshaffry.com/GameCode/thread.php?threadid=732
http://www.codeplex.com/Wikipage?ProjectName=elephant

De plus, les commentaires eux-mêmes semblent avoir une discussion assez approfondie sur la manière dont vous pourriez coder un tel système.