Entity Component System C#

Question

Je suis en train de créer un moteur de jeu 2D en C#. En ce moment, je suis en train de mettre en place un système de composants d'entité.

Ma structure est la suivante:

• Classe Entité: Contient une liste des IGameComponent « s, vous pouvez ajouter, supprimer et supprimer tout composant par type de classe. . (C.-à-; entity.RemoveComponent(typeof(Transform)); Il contient également une entité mère, et une entité enfant liste
• IGameComponent Interface: Pour l'instant, est juste une interface vide (Notez que: Les composants ne contiennent que des données, et non la fonctionnalité)
..
• Entité Piscine:.. Contient une liste de tous les objets actifs dans le jeu, il est également utilisé pour créer et détruire des entités

tout est tellement grande

Cependant, je suis confronté à un problème. ne contiennent que des données J'ai besoin d'un moyen d'initialiser, mettre à jour et rendre les composants et je préfère ne pas simplement ajouter un tas de méthodes virtuelles à une classe GameComponent, mais je ne connais pas d'autre moyen de le résoudre.

Quelles sont mes options?

EDIT:

Je l'ai vu que l'unité utilise des méthodes comme « SendMessage » que je ne peux que supposer la réflexion utilise pour appeler des méthodes. Devrais-je mettre en place quelque chose de similaire?

Answer 1

Je ne sais pas si vous en avez toujours besoin, mais j'ai fait quelque chose de similaire il y a quelques années et cela pourrait vous aider. Il est écrit en C# construit sur monogame/XNA

Vous classe gameobject peut ressembler à ceci

public class GameObject 
{ 
    List<GameObjectComponent> _goComponent = new List<GameObjectComponent(); 

    public T GetComponent<T>() where T : GameObjectComponent 
    { 
     foreach (GameObjectComponent goc in _goComponent) 
      if (goc.GetType().Equals(typeof(T))) 
       return (T)goc; 
     return null; 
    } 

    public void AddComponent(GameObjectComponent gameObjectComponent) 
    { 
     _goComponent.Add(gameObjectComponent); 
     gameObjectComponent.gameObject = this; 
     gameObjectComponent.Init(); 
    } 

    public virtual void Update(GameTime gameTime) 
    { 
     foreach (GameObjectComponent _goc in _goComponent) 
      _goc.Update(gameTime); 
    } 

    public static void Instantiate(GameObject gameObject) 
    { 
     Scene._AddedGO.Add(gameObject); 
    } 

    public static void Destroy(GameObject gameObject) 
    { 
     Scene._RemoveGO.Add(gameObject); 
    } 

} 

GameObjectComponent est similaire à MonoBehaivior de Unity3D

public class GameObjectComponent 
{ 

    public GameObject gameObject; 

    public GameObjectComponent() 
    { 

    } 

    public virtual void Init() 
    { 

    } 

    public virtual void Update(GameTime gameTime) 
    { 

    } 
} 

puis vous héritez d'autres classes comme ainsi:

public class Sprite : GameObjectComponent 
{ 
    public Texture2D texture; 
    public Vector2 origin = Vector2.Zero; 
    public Rectangle rect; 
    public Rectangle sourceRect; 
    public Color color = Color.White; 
    public float rotation = 0f; 
    private float layerDepth = 0f; 
    public int scale = 1; 

    public Sprite() 
    { 

    } 

    public void Load(string path) 
    { 
     texture = Setup.ContentDevice.Load<Texture2D>(path); 
    } 

} 

et alors vous pouvez enfin vous créer Joueur GameObject

class Player : GameObjectComponent 
{ 
    float speed = 150f; 
    KeyboardState keyState; 

    float pos_X; 
    float pos_Y; 
    int rect_X; 
    int rect_Y; 

    public Player(float x, float y, int rx, int ry) 
    { 
     pos_X = x; 
     pos_Y = y; 
     rect_X = rx; 
     rect_Y = ry; 
    } 

    public override void Init() 
    { 
     Sprite sprite = new Sprite(); 
     gameObject.AddComponent(sprite); 

     gameObject.GetComponent<Sprite>().Load("Sprites/MainGuySpriteSheet_0"); 
     gameObject.GetComponent<Sprite>().scale = 1; 
     gameObject.GetComponent<Sprite>().rect = new Rectangle(46, 0, 32, 36); 


     Transform transform = new Transform(); 
     gameObject.AddComponent(transform); 
     // gameObject.GetComponent<Transform>().position = new Vector2(Screen.width/2 - gameObject.GetComponent<Sprite>().rect.Width, Screen.height/2 - gameObject.GetComponent<Sprite>().rect.Height); 
     gameObject.GetComponent<Transform>().position = new Vector2(pos_X, pos_Y - 32 * (gameObject.GetComponent<Sprite>().scale - 1)); 

     RectCollider collider = new RectCollider(); 
     gameObject.AddComponent(collider); 
     gameObject.GetComponent<RectCollider>().Set(gameObject.GetComponent<Sprite>(), gameObject.GetComponent<Transform>()); 

     SpriteRenderer render = new SpriteRenderer(); 
     gameObject.AddComponent(render); 
     gameObject.GetComponent<SpriteRenderer>().layer = 1; 
     gameObject.GetComponent<SpriteRenderer>().Set(gameObject.GetComponent<Sprite>()); 
    } 

    public override void Update(GameTime gameTime) 
    { 
     //movex = transform.position.X -= 25 * gameTime.DeltaTime(); 


     if (Keyboard.GetState().IsKeyDown(Keys.Left)) 
      gameObject.GetComponent<Transform>().Move(-speed * gameTime.DeltaTime(), 0); 

     else if (Keyboard.GetState().IsKeyDown(Keys.Right)) 
      gameObject.GetComponent<Transform>().Move(speed * gameTime.DeltaTime(), 0); 

     else if (Keyboard.GetState().IsKeyDown(Keys.Down)) 
      gameObject.GetComponent<Transform>().Move(0, speed * gameTime.DeltaTime()); 

     else if (Keyboard.GetState().IsKeyDown(Keys.Up)) 
      gameObject.GetComponent<Transform>().Move(0, -speed * gameTime.DeltaTime()); 

     if (Keyboard.GetState().IsKeyDown(Keys.Space) && !keyState.IsKeyDown(Keys.Space)) 
     { 
      GameObject tomato = new GameObject(); 
      tomato.AddComponent(new Tomato()); 
      tomato.GetComponent<Transform>().position = gameObject.GetComponent<Transform>().position; 
      GameObject.Instantiate(tomato); 
     } 

     if (Keyboard.GetState().IsKeyDown(Keys.Q) && !keyState.IsKeyDown(Keys.Q)) 
     { 
      SceneManager.LoadScene(new AnotherOne()); 
     } 

     keyState = Keyboard.GetState(); 


     gameObject.GetComponent<Transform>().position.Y = MathHelper.Clamp(gameObject.GetComponent<Transform>().position.Y, 0, Screen.bounds.Height - gameObject.GetComponent<Sprite>().rect.Height * gameObject.GetComponent<Sprite>().scale); 
     gameObject.GetComponent<Transform>().position.X = MathHelper.Clamp(gameObject.GetComponent<Transform>().position.X, 0, Screen.bounds.Width - gameObject.GetComponent<Sprite>().rect.Width * gameObject.GetComponent<Sprite>().scale); 
    } 

} 

J'espère que ce n'est pas trop déroutant et vous aide un peu. Pour le rendre plus clair, je laisse un lien vers le git ici: https://github.com/Memorix101/MonoGame_ComponentSystem

Cheers, Memorix101 :)