encompass-cs/encompass-cs/ComponentManager.cs

using System;
using System.Collections.Generic;
using MoonTools.FastCollections;

namespace Encompass
{
    internal class ComponentManager
    {
        private readonly DrawLayerManager drawLayerManager;

        private readonly ComponentStore existingComponentStore;
        private readonly ComponentStore immediateComponentStore;
        private readonly ComponentDeltaStore replayStore;
        private ComponentStore upToDateComponentStore;

        public Dictionary<Type, int> TypeToIndex { get; }

        private readonly HashSet<int> entitiesMarkedForRemoval = new HashSet<int>();

        internal ComponentBitSet ImmediateBits { get { return immediateComponentStore.ComponentBitSet; } }
        internal ComponentBitSet ExistingBits { get { return existingComponentStore.ComponentBitSet; } }

        public ComponentManager(DrawLayerManager drawLayerManager, Dictionary<Type, int> typeToIndex)
        {
            this.drawLayerManager = drawLayerManager;
            existingComponentStore = new ComponentStore(typeToIndex);
            immediateComponentStore = new ComponentStore(typeToIndex);
            replayStore = new ComponentDeltaStore(typeToIndex);
            upToDateComponentStore = new ComponentStore(typeToIndex);
            TypeToIndex = typeToIndex;
        }

        public void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
        {
            existingComponentStore.RegisterComponentType<TComponent>();
            immediateComponentStore.RegisterComponentType<TComponent>();
            replayStore.RegisterComponentType<TComponent>();
            upToDateComponentStore.RegisterComponentType<TComponent>();
        }

        internal void SetExistingComponentStore(ComponentStore componentStore)
        {
            existingComponentStore.SwapWith(componentStore);
        }

        internal void SetUpToDateComponentStore(ComponentStore componentStore)
        {
            upToDateComponentStore.SwapWith(componentStore);
        }

        internal void RegisterDrawableComponent<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent
        {
            drawLayerManager.RegisterComponentWithLayer(entityID, component, layer);
        }

        internal void WriteComponents()
        {
            existingComponentStore.UpdateUsing(replayStore);
            existingComponentStore.ClearAllPriorities();
            upToDateComponentStore.ClearAllPriorities();
            immediateComponentStore.ClearAll();
            replayStore.ClearAll();
        }

        internal bool AddImmediateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
        {
            if (immediateComponentStore.Set(entityID, component, priority))
            {
                replayStore.Set(entityID, component);
                upToDateComponentStore.Set(entityID, component);
                return true;
            }

            return false;
        }

        internal void AddImmediateComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
        {
            immediateComponentStore.Set(entityID, component);
            replayStore.Set(entityID, component);
            upToDateComponentStore.Set(entityID, component);
        }

        internal bool UpdateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
        {
            var result = upToDateComponentStore.Set(entityID, component, priority);
            if (result)
            {
                replayStore.Set(entityID, component);
            }
            return result;
        }

        internal void AddComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
        {
            upToDateComponentStore.Set(entityID, component);
            replayStore.Set(entityID, component);
        }

        // existing or immediate reads

        internal IEnumerable<(TComponent, int)> ReadExistingAndImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            return upToDateComponentStore.All<TComponent>();
        }

        internal (TComponent, int) ReadFirstExistingOrImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
        {
            if (!SomeExistingOrImmediateComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
            var enumerator = ReadExistingAndImmediateComponentsByType<TComponent>().GetEnumerator();
            enumerator.MoveNext();
            return enumerator.Current;
        }

        internal bool SomeExistingOrImmediateComponent<TComponent>() where TComponent : struct, IComponent
        {
            return upToDateComponentStore.Any<TComponent>();
        }

        // existing reads

        internal (TComponent, int) ReadFirstExistingComponentByType<TComponent>() where TComponent : struct, IComponent
        {
            if (!SomeExistingComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
            var enumerator = GetComponentsIncludingEntity<TComponent>().GetEnumerator();
            enumerator.MoveNext();
            return enumerator.Current;
        }

        internal bool SomeExistingComponent<TComponent>() where TComponent : struct, IComponent
        {
            return existingComponentStore.Any<TComponent>();
        }

        // immediate reads

        internal IEnumerable<(TComponent, int)> ReadImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            return immediateComponentStore.All<TComponent>();
        }

        internal (TComponent, int) ReadFirstImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
        {
            if (!SomeImmediateComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
            var enumerator = ReadImmediateComponentsByType<TComponent>().GetEnumerator();
            enumerator.MoveNext();
            return enumerator.Current;
        }

        internal bool SomeImmediateComponent<TComponent>() where TComponent : struct, IComponent
        {
            return immediateComponentStore.Any<TComponent>();
        }

        // component getters

        internal TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return upToDateComponentStore.Get<TComponent>(entityID);
        }

        internal TComponent ReadExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return existingComponentStore.Get<TComponent>(entityID);
        }

        internal TComponent ReadImmediateComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return immediateComponentStore.Get<TComponent>(entityID);
        }

        // has checkers

        internal bool HasExistingOrImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return upToDateComponentStore.Has<TComponent>(entityID);
        }

        internal bool HasExistingOrImmediateComponent(int entityID, Type type)
        {
            return upToDateComponentStore.Has(type, entityID);
        }

        internal bool HasExistingComponent<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return existingComponentStore.Has<TComponent>(entityID);
        }

        internal bool HasExistingComponent(int entityID, Type type)
        {
            return existingComponentStore.Has(type, entityID);
        }

        internal bool HasImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return immediateComponentStore.Has<TComponent>(entityID);
        }

        internal bool HasImmediateComponent(int entityID, Type type)
        {
            return immediateComponentStore.Has(type, entityID);
        }

        internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
        {
            return existingComponentStore.All<TComponent>();
        }

        internal IEnumerable<TComponent> GetComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            foreach (var pair in existingComponentStore.All<TComponent>())
            {
                yield return pair.Item1;
            }
        }

        internal TComponent GetComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return existingComponentStore.Get<TComponent>(entityID);
        }

        internal bool EntityHasComponentOfType<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return existingComponentStore.Has<TComponent>(entityID);
        }

        internal void MarkAllComponentsOnEntityForRemoval(int entityID)
        {
            entitiesMarkedForRemoval.Add(entityID);
        }

        internal void RemoveMarkedComponents()
        {
            foreach (var entityID in entitiesMarkedForRemoval)
            {
                existingComponentStore.Remove(entityID);
                immediateComponentStore.Remove(entityID);
                replayStore.Remove(entityID);
                upToDateComponentStore.Remove(entityID);
                drawLayerManager.UnRegisterEntityWithLayer(entityID);
            }

            entitiesMarkedForRemoval.Clear();
        }

        public bool RemoveImmediate<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
        {
            if (immediateComponentStore.Remove<TComponent>(entityID, priority))
            {
                replayStore.Remove<TComponent>(entityID, priority);
                upToDateComponentStore.Remove<TComponent>(entityID, priority);
                drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
                return true;
            }
            return false;
        }

        public void Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
        {
            if (upToDateComponentStore.Remove<TComponent>(entityID, priority))
            {
                replayStore.Remove<TComponent>(entityID, priority);
                drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
            }
        }

        public bool UpToDateEntityIsEmpty(int entityID)
        {
            return upToDateComponentStore.EntityBitArray(entityID).AllFalse();
        }
    }
}