encompass-cs/encompass-cs/ComponentManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Encompass.Exceptions;
using Collections.Pooled;

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

        private readonly Dictionary<Guid, Type> componentIDToType = new Dictionary<Guid, Type>();
        private readonly Dictionary<Guid, IComponent> IDToComponent = new Dictionary<Guid, IComponent>();
        private readonly Dictionary<Guid, PooledSet<Guid>> entityIDToComponentIDs = new Dictionary<Guid, PooledSet<Guid>>();
        private readonly Dictionary<Guid, Guid> componentIDToEntityID = new Dictionary<Guid, Guid>();

        private readonly Dictionary<Guid, PooledDictionary<Type, HashSet<Guid>>> entityIDToComponentTypeToComponentIDs = new Dictionary<Guid, PooledDictionary<Type, HashSet<Guid>>>();

        private readonly Dictionary<Type, HashSet<Guid>> typeToComponentIDs = new Dictionary<Type, HashSet<Guid>>();

        private readonly HashSet<Guid> componentsMarkedForRemoval = new HashSet<Guid>();

        private readonly Dictionary<Guid, IComponent> pendingUpdates = new Dictionary<Guid, IComponent>();

        public ComponentManager(DrawLayerManager drawLayerManager)
        {
            this.drawLayerManager = drawLayerManager;
        }

        internal void RegisterEntity(Guid entityID)
        {
            entityIDToComponentIDs.Add(entityID, new PooledSet<Guid>());
            entityIDToComponentTypeToComponentIDs.Add(entityID, new PooledDictionary<Type, HashSet<Guid>>(ClearMode.Never));
        }

        internal Guid NextID()
        {
            return Guid.NewGuid();
        }

        internal Guid AddComponent<TComponent>(Entity entity, Guid componentID, TComponent component) where TComponent : struct, IComponent
        {
            IDToComponent[componentID] = component;
            componentIDToType[componentID] = typeof(TComponent);

            if (!typeToComponentIDs.ContainsKey(typeof(TComponent)))
            {
                typeToComponentIDs.Add(typeof(TComponent), new HashSet<Guid>());
            }

            typeToComponentIDs[typeof(TComponent)].Add(componentID);

            entityIDToComponentIDs[entity.ID].Add(componentID);
            if (!entityIDToComponentTypeToComponentIDs[entity.ID].ContainsKey(typeof(TComponent))) {
                entityIDToComponentTypeToComponentIDs[entity.ID].Add(typeof(TComponent), new HashSet<Guid>());
            }
            entityIDToComponentTypeToComponentIDs[entity.ID][typeof(TComponent)].Add(componentID);

            componentIDToEntityID[componentID] = entity.ID;

            return componentID;
        }

        internal Guid AddDrawComponent<TComponent>(Entity entity, Guid componentID, TComponent component, int layer = 0) where TComponent : struct, IComponent
        {
            AddComponent(entity, componentID, component);
            drawLayerManager.RegisterComponentWithLayer(componentID, layer);
            return componentID;
        }


        internal IEnumerable<Guid> GetComponentIDsByEntityID(Guid entityID)
        {
            if (entityIDToComponentIDs.TryGetValue(entityID, out PooledSet<Guid> idSet))
            {
                return idSet;
            }
            return Enumerable.Empty<Guid>();
        }

        internal IEnumerable<(Guid, TComponent)> GetComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            if (typeToComponentIDs.TryGetValue(typeof(TComponent), out HashSet<Guid> idSet))
            {
                return idSet.Select(id => (id, (TComponent)IDToComponent[id]));
            }
            return Enumerable.Empty<(Guid, TComponent)>();
        }

        internal IEnumerable<ValueTuple<Guid, TComponent>> GetComponentsByEntityAndType<TComponent>(Guid entityID) where TComponent : struct, IComponent
        {
            if (entityIDToComponentTypeToComponentIDs.ContainsKey(entityID) && entityIDToComponentTypeToComponentIDs[entityID].TryGetValue(typeof(TComponent), out HashSet<Guid> idSet))
            {
                return idSet.Select(id => (id, (TComponent)IDToComponent[id]));
            }
            return Enumerable.Empty<(Guid, TComponent)>();
        }

        internal bool EntityHasComponentOfType<TComponent>(Guid entityID) where TComponent : struct, IComponent
        {
            if (entityIDToComponentTypeToComponentIDs.ContainsKey(entityID) && entityIDToComponentTypeToComponentIDs[entityID].TryGetValue(typeof(TComponent), out HashSet<Guid> idSet))
            {
                return idSet.Count > 0;
            }

            return false;
        }

        internal bool ComponentOfTypeExists<TComponent>() where TComponent : struct, IComponent
        {
            if (typeToComponentIDs.TryGetValue(typeof(TComponent), out HashSet<Guid> idSet))
            {
                return idSet.Count > 0;
            }

            return false;
        }

        internal IComponent GetComponentByID(Guid componentID)
        {
            return IDToComponent[componentID];
        }

        internal Type GetComponentTypeByID(Guid componentID)
        {
            return componentIDToType[componentID];
        }

        internal Guid GetEntityIDByComponentID(Guid componentID)
        {
            return componentIDToEntityID[componentID];
        }

        internal void AddUpdateComponentOperation<TComponent>(Guid componentID, TComponent newComponentValue) where TComponent : struct, IComponent
        {
            if (pendingUpdates.ContainsKey(componentID))
            {
                throw new RepeatUpdateComponentException("Component {0} with ID {1} was updated multiple times this frame", typeof(TComponent).Name, componentID);
            }

            pendingUpdates.Add(componentID, newComponentValue);
        }

        internal void PerformComponentUpdates()
        {
            foreach (var idPair in pendingUpdates)
            {
                IDToComponent[idPair.Key] = idPair.Value;
            }

            pendingUpdates.Clear();
        }

        internal void MarkAllComponentsOnEntityForRemoval(Guid entityID)
        {
            foreach (var componentID in GetComponentIDsByEntityID(entityID))
            {
                MarkForRemoval(componentID);
            }
        }

        internal void MarkForRemoval(Guid componentID)
        {
            componentsMarkedForRemoval.Add(componentID);
        }

        internal void RemoveMarkedComponents()
        {
            foreach (var componentID in componentsMarkedForRemoval)
            {
                Remove(componentID);
            }

            componentsMarkedForRemoval.Clear();
        }

        private void Remove(Guid componentID)
        {
            var type = componentIDToType[componentID];

            var entityID = componentIDToEntityID[componentID];
            if (entityIDToComponentIDs.ContainsKey(entityID))
            {
                entityIDToComponentIDs[entityID].Remove(componentID);
            }

            IDToComponent.Remove(componentID);
            componentIDToType.Remove(componentID);
            componentIDToEntityID.Remove(componentID);
            typeToComponentIDs[type].Remove(componentID);

            drawLayerManager.UnRegisterComponentWithLayer(componentID);
        }

        public void RegisterDestroyedEntity(Guid entityID)
        {
            entityIDToComponentIDs[entityID].Dispose();
            entityIDToComponentIDs.Remove(entityID);

            foreach (var set in entityIDToComponentTypeToComponentIDs[entityID].Values)
            {
                set.Clear();
            }
            entityIDToComponentTypeToComponentIDs[entityID].Dispose();
            entityIDToComponentTypeToComponentIDs.Remove(entityID);
        }
    }
}