La manipulation d'entités dans un jeu

Vous devez regarder dans les composants, plutôt que l'héritage de cette. Par exemple, dans mon moteur, j'ai (en simplifié):

class GameObject
{
private:
    std::map<int, GameComponent*> m_Components;
}; //eo class GameObject

J'ai les diverses composantes qui font des choses différentes:

class GameComponent
{
}; //eo class GameComponent

class LightComponent : public GameComponent //represents a light
class CameraComponent : public GameComponent //represents a camera
class SceneNodeComponent : public GameComponent //represents a scene node
class MeshComponent : public GameComponent //represents a mesh and material
class SoundComponent : public GameComponent //can emit sound
class PhysicsComponent : public GameComponent //applies physics
class ScriptComponent : public GameComponent //allows scripting

Ces composants peut être ajouté à un objet de jeu pour induire le comportement. Ils peuvent communiquer par le biais d'un système de messagerie, et des choses qui nécessitent une mise à jour au cours de la boucle principale d'enregistrer une image de l'auditeur. Ils peuvent agir de façon indépendante et en toute sécurité ajoutés/supprimés au moment de l'exécution. Je trouve que c'est une très extensible système.

EDIT: toutes mes Excuses, je vais chair ce un peu, mais je suis dans le milieu de quelque chose tout de suite 🙂

OriginalL'auteur Moo-Juice

1 Une petite chose - pourquoi voulez-vous changer l'ID de l'entité? Normalement, elle est constante et initialisé lors de la construction, et c'est tout:

class CEntity
{ 
     const int m_id;
   public:
     CEntity(int id) : m_id(id) {}
}

---

Pour les autres choses, il y a différentes approches, le choix dépend du nombre de type de fonctions spécifiques sont là (et comment vous pouvez vous repdict).

---

Ajouter à tous les

La possibilité la plus simple est juste de l'ajouter à toutes les méthodes de l'interface de base, et de les mettre en œuvre en tant que non-op dans les classes qui ne le supportent pas. Cela peut sembler comme mauvais conseiller, mais est un acceptabel dénormalisation, si il y a très peu de méthodes qui ne s'appliquent pas, et vous pouvez supposer que l'ensemble des méthodes de ne pas augmenter considérablement avec les futures exigences.

Vous mayn même de mettre en œuvre une base de "mécanisme de découverte", par exemple

 class CEntity
 {
   public:
     ...
     virtual bool CanMove() = 0;
     virtual void Move(CPoint target) = 0;
 }

N'en faites pas trop! Il est facile de commencer de cette façon, et puis de s'y tenir, même lorsqu'il crée un énorme gâchis de votre code. Il peut être mièvres "intentionnel de la dénormalisation de la hiérarchie des types" - mais à la fin c'est juste un hack qui permet de résoudre quelques problèmes rapidement, mais il a rapidement fait mal quand la demande augmente.

---

Vrai découverte du Type de

l'aide et dynamic_cast, vous pouvez lancer votre objet de CEntity à CFastCat. Si l'entité est en fait un CReallyUnmovableBoulder, le résultat sera un pointeur null. De cette façon, vous pouvez sonde un objet pour son type réel, et de réagir en conséquence.

CFastCat * fastCat = dynamic_cast<CFastCat *>(entity) ;
if (fastCat != 0)
   fastCat->Meow();

Que le mécanisme fonctionne bien si ce n'est que peu de logique, liée à type de méthodes spécifiques. C'est pas une bonne solution si vous vous retrouvez avec des chaînes où vous sonder pour de nombreux types, et d'agir en conséquence:

//-----BAD BAD BAD BAD Code -----
CFastCat * fastCat = dynamic_cast<CFastCat *>(entity) ;
if (fastCat != 0)
   fastCat->Meow();

CBigDog * bigDog = dynamic_cast<CBigDog *>(entity) ;
if (bigDog != 0)
   bigDog->Bark();

CPebble * pebble = dynamic_cast<CPebble *>(entity) ;
if (pebble != 0)
   pebble->UhmWhatNoiseDoesAPebbleMake();

Qui habituellement signifie que vos méthodes virtuelles ne sont pas choisis avec soin.

---

Interfaces

Ci-dessus peut être étendu à des interfaces, lorsque le type de fonctionnalités spécifiques n'est pas unique, mais des groupes de méthodes. Ils ne sont#t pris en charge très bien en C++, mais c'est supportable. E. g. vos objets ont des caractéristiques différentes:

class IMovable
{
   virtual void SetSpeed() = 0;
   virtual void SetTarget(CPoint target) = 0;
   virtual CPoint GetPosition() = 0;
   virtual ~IMovable() {}
}

class IAttacker
{
   virtual int GetStrength() = 0;
   virtual void Attack(IAttackable * target) = 0;
   virtual void SetAnger(int anger) = 0;
   virtual ~IAttacker() {}
}

De vos différents objets héritent de la classe de base et une ou plusieurs interfaces:

class CHero : public CEntity, public IMovable, public IAttacker 

Et encore une fois, vous pouvez utiliser dynamic_cast de sonde pour les interfaces sur n'importe quelle entité.

C'est assez extensible, et généralement le moyen le plus sûr d'aller lorsque vous n'êtes pas sûr. C'est un peu une manière plus détaillé que les solutions ci-dessus, mais peut faire face très bien avec inattendus de futurs changements. L'affacturage les fonctionnalités des interfaces est pas facile, il faut une certaine expérience pour obtenir une sensation pour elle.

---

Modèle visiteur

La modèle visiteur nécessite beaucoup de frappe, mais il vous permet d'ajouter des fonctionnalités à des classes sans modification de ces classes.

Dans votre contexte, cela signifie que vous pouvez construire votre structure d'entité, mais de mettre en place leurs activités séparément. Ceci est habituellement utilisé lorsque vous avez très distinctes des opérations sur des entités, vous ne pouvez pas modifier librement les classes, ou l'ajout de la fonctionnalité pour les classes vivement de violer la seule responsabilité de principe.

Cela peut faire face à pratiquement toutes les exigence de modification (à condition que votre entités elles-mêmes sont bien pris en compte d').

(Je ne suis qu'un lien, parce que la plupart des gens ont un moment pour envelopper leur tête autour de lui, et je recommande de ne pas utiliser, sauf si vous avez connu les limites d'autres méthodes)

OriginalL'auteur peterchen