Параллелизируйте код во вложенных циклах

Entity-components-system запрашивает конкретную конструкцию.

ECS следует принципу композиции по наследованию

blockquote>

При работе с пулами компонентов, которые по сути являются необработанными данными, имеет смысл обрабатывать эти данные со ссылкой на фактический тип компонента. - учитывая, что вы захотите применить определенное поведение для каждого.

Шаблон декоратора хорошо сочетается с композицией, добавляя поведение по типам переноса. Это также позволяет EntityManager делегировать обязанности пулам компонентов вместо того, чтобы иметь одно массивное дерево решений, которое должно обрабатывать все случаи.

Давайте реализуем пример.

Предположим, есть функция рисования. Это будет «Система», которая перебирает все объекты, которые имеют как физический, так и видимый компоненты, и рисует их. Видимый компонент может обычно иметь некоторую информацию о том, как должен выглядеть объект (например, человек, монстр, искры, летающие стрелы) и использовать физический компонент, чтобы знать, где его нарисовать.

blockquote>

1. Entity.cs

Объект обычно состоит из идентификатора и списка компонентов, которые к нему прикреплены.

blockquote>

class Entity
{
    public Entity(Guid entityId)
    {
        EntityId = entityId;
        Components = new List();
    }

    public Guid EntityId { get; }
    public List Components { get; }
}

2. Component.cs

Начиная с интерфейса маркера.

interface IComponent { }

enum Appearance : byte
{
    Human,
    Monster,
    SparksFlyingAround,
    FlyingArrow
}

class VisibleComponent : IComponent
{
    public Appearance Appearance { get; set; }
}

class PhysicalComponent : IComponent
{
    public double X { get; set; }
    public double Y { get; set; }
}

3. System.cs

Добавление коллекции для SystemEntities.

interface ISystem
{
    ISet SystemEntities { get; }
    Type[] ComponentTypes { get; }

    void Run();
}

class DrawingSystem : ISystem
{
    public DrawingSystem(params Type[] componentTypes)
    {
        ComponentTypes = componentTypes;
        SystemEntities = new HashSet();
    }

    public ISet SystemEntities { get; }

    public Type[] ComponentTypes { get; }

    public void Run()
    {
        foreach (var entity in SystemEntities)
        {
            Draw(entity);
        }
    }

    private void Draw(Guid entity) { /*Do Magic*/ }
}

4. ComponentPool.cs

Далее, мы заложим основу для того, что грядет. Наши пулы компонентов также должны иметь неуниверсальный интерфейс, к которому мы можем прибегнуть, когда не можем предоставить тип компонента.

interface IComponentPool
{
    void RemoveEntity(Guid entityId);
    bool ContainsEntity(Guid entityId);
}

interface IComponentPool : IComponentPool
{
    void AddEntity(Guid entityId, T component);
}

class ComponentPool : IComponentPool
{
    private Dictionary component = new Dictionary();

    public void AddEntity(Guid entityId, T component)
    {
        this.component.Add(entityId, component);
    }

    public void RemoveEntity(Guid entityId)
    {
        component.Remove(entityId);
    }

    public bool ContainsEntity(Guid entityId)
    {
        return component.ContainsKey(entityId);
    }
}

Следующим шагом является декоратор пула. Шаблон декоратора реализуется посредством предоставления того же интерфейса, что и класс, который он переносит, применяя любое желаемое поведение в процессе. В нашем случае мы хотим проверить, обладают ли добавленные объекты всеми типами компонентов, которые требуются системе. И если они это сделают, добавьте их в коллекцию.

class PoolDecorator : IComponentPool
{
    private readonly IComponentPool wrappedPool;
    private readonly EntityManager entityManager;
    private readonly ISystem system;

    public PoolDecorator(IComponentPool componentPool, EntityManager entityManager, ISystem system)
    {
        this.wrappedPool = componentPool;
        this.entityManager = entityManager;
        this.system = system;
    }

    public void AddEntity(Guid entityId, T component)
    {
        wrappedPool.AddEntity(entityId, component);

        if (system.ComponentTypes
            .Select(t => entityManager.GetComponentPool(t))
            .All(p => p.ContainsEntity(entityId)))
        {
            system.SystemEntities.Add(entityId);
        }
    }

    public void RemoveEntity(Guid entityId)
    {
        wrappedPool.RemoveEntity(entityId);
        system.SystemEntities.Remove(entityId);
    }

    public bool ContainsEntity(Guid entityId)
    {
        return wrappedPool.ContainsEntity(entityId);
    }
}

Как уже говорилось, вы можете возложить бремя проверки и управления коллекциями системы на EntityManager. Но наш текущий дизайн имеет тенденцию уменьшать сложность и обеспечивать большую гибкость в долгосрочной перспективе. Просто оберните пул один раз для каждой системы, к которой он принадлежит. Если система требует поведения не по умолчанию, то вы можете создать новый декоратор, специализированный для этой системы - без вмешательства в другие системы.

5. EntityManager.cs

Оркестратор (он же посредник, контроллер, ...)

class EntityManager
{
    List systems;
    Dictionary componentPools;

    public EntityManager()
    {
        systems = new List();
        componentPools = new Dictionary();
        ActiveEntities = new HashSet();
    }

    public ISet ActiveEntities { get; }

    public Guid CreateEntity()
    {
        Guid entityId;
        do entityId = Guid.NewGuid();
        while (!ActiveEntities.Add(entityId));

        return entityId;
    }

    public void DestroyEntity(Guid entityId)
    {
        componentPools.Values.Select(kp => (IComponentPool)kp).ToList().ForEach(c => c.RemoveEntity(entityId));
        systems.ForEach(c => c.SystemEntities.Remove(entityId));
        ActiveEntities.Remove(entityId);
    }

    public void AddSystems(params ISystem[] system)
    {
        systems.AddRange(systems);
    }

    public IComponentPool GetComponentPool(Type componentType)
    {
        return (IComponentPool)componentPools[componentType];
    }

    public IComponentPool GetComponentPool() where TComponent : IComponent
    {
        return (IComponentPool)componentPools[typeof(TComponent)];
    }

    public void AddComponentPool(IComponentPool componentPool) where TComponent : IComponent
    {
        componentPools.Add(typeof(TComponent), componentPool);
    }

    public void AddComponentToEntity(Guid entityId, TComponent component) where TComponent : IComponent
    {
        var pool = GetComponentPool();
        pool.AddEntity(entityId, component);
    }

    public void RemoveComponentFromEntity(Guid entityId) where TComponent : IComponent
    {
        var pool = GetComponentPool();
        pool.RemoveEntity(entityId);
    }
}

6. Program.cs
[1128 ]

Где все это объединяется.

class Program
{
    static void Main(string[] args)
    {
        #region Composition Root

        var entityManager = new EntityManager();

        var drawingComponentTypes = 
            new Type[] {
                typeof(VisibleComponent),
                typeof(PhysicalComponent) };

        var drawingSystem = new DrawingSystem(drawingComponentTypes);

        var visibleComponent =
            new PoolDecorator(
                new ComponentPool(), entityManager, drawingSystem);

        var physicalComponent =
            new PoolDecorator(
                new ComponentPool(), entityManager, drawingSystem);

        entityManager.AddSystems(drawingSystem);
        entityManager.AddComponentPool(visibleComponent);
        entityManager.AddComponentPool(physicalComponent);

        #endregion

        var entity = new Entity(entityManager.CreateEntity());

        entityManager.AddComponentToEntity(
            entity.EntityId,
            new PhysicalComponent() { X = 0, Y = 0 });

        Console.WriteLine($"Added physical component, number of drawn entities: {drawingSystem.SystemEntities.Count}.");

        entityManager.AddComponentToEntity(
            entity.EntityId,
            new VisibleComponent() { Appearance = Appearance.Monster });

        Console.WriteLine($"Added visible component, number of drawn entities: {drawingSystem.SystemEntities.Count}.");

        entityManager.RemoveComponentFromEntity(entity.EntityId);

        Console.WriteLine($"Removed visible component, number of drawn entities: {drawingSystem.SystemEntities.Count}.");

        Console.ReadLine();
    }
}

---

и, возможно, возможно создать коллекции, которые не требуют entityId, поэтому они хранят только ссылку на компонент, который должен быть обновлен.

blockquote>

Как упоминалось в ссылочной вики, это на самом деле не рекомендуется.

Обычной практикой является использование уникального идентификатора для каждого объекта. Это не является обязательным требованием, но оно имеет несколько преимуществ:

• На объект можно ссылаться, используя идентификатор вместо указателя. Это более надежно, поскольку позволяет уничтожить объект, не оставляя висящих указателей.
• Это помогает для внешнего сохранения состояния. Когда состояние загружается снова, нет необходимости восстанавливать указатели.
• Данные могут быть перемешаны в памяти по мере необходимости.
• Идентификаторы объекта могут использоваться при связи по сети, чтобы однозначно идентифицировать объект.

blockquote>