encompass-cs/src/ComponentManager.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace Encompass {
    internal class ComponentManager {
        private Dictionary<uint, List<Component>> entityIDToComponents = new Dictionary<uint, List<Component>>();

        private Dictionary<Type, List<Component>> activeComponents = new Dictionary<Type, List<Component>>();
        private Dictionary<Type, List<Component>> inactiveComponents = new Dictionary<Type, List<Component>>();

        private List<Component> componentsToActivate = new List<Component>();
        private List<Component> componentsToDeactivate = new List<Component>();
        private List<Component> componentsToRemove = new List<Component>();

        internal TComponent CreateComponent<TComponent>(uint entityID) where TComponent : Component, new() {
            var component = new TComponent();

            if (!entityIDToComponents.ContainsKey(entityID)) {
                entityIDToComponents.Add(entityID, new List<Component>());
            }

            entityIDToComponents[entityID].Add(component);

            if (!activeComponents.ContainsKey(typeof(TComponent))) {
                activeComponents.Add(typeof(TComponent), new List<Component>());
                inactiveComponents.Add(typeof(TComponent), new List<Component>());
            }

            MarkForActivation(component);

            return component;
        }

        internal IEnumerable<Component> GetComponentsByEntity(uint entityID) {
            return entityIDToComponents[entityID];
        }

        internal IEnumerable<TComponent> GetActiveComponentsByType<TComponent>() where TComponent : Component {
            return activeComponents[typeof(TComponent)].Cast<TComponent>();
        }

        internal IEnumerable<TComponent> GetComponentsByEntityAndType<TComponent>(uint entityID) where TComponent : Component {
            var entity_components = GetComponentsByEntity(entityID);
            var active_components_by_type = GetActiveComponentsByType<TComponent>();
            return entity_components.Intersect(active_components_by_type).Cast<TComponent>();
        }

        internal bool EntityHasComponentOfType<TComponent>(uint entityID) where TComponent : Component {
            return GetComponentsByEntityAndType<TComponent>(entityID).Any();
        }

        internal void RemoveAllComponentsFromEntity(uint entityID) {
            var components = GetComponentsByEntity(entityID);

            foreach (var component in components) {
                activeComponents[component.GetType()].Remove(component);
                inactiveComponents[component.GetType()].Remove(component);
            }

            entityIDToComponents.Remove(entityID);
        }

        internal void MarkForActivation(Component component) {
            componentsToActivate.Add(component);
        }

        internal void MarkForRemoval(Component component) {
            componentsToRemove.Add(component);
        }

        internal void ActivateComponents() {
            foreach (var component in componentsToActivate) {
                activeComponents[component.GetType()].Add(component);
                inactiveComponents[component.GetType()].Remove(component);
            }

            componentsToActivate.Clear();
        }

        internal void RemoveComponents() {
            foreach (var component in componentsToRemove) {
                activeComponents[component.GetType()].Remove(component);
                inactiveComponents[component.GetType()].Remove(component);
            }

            componentsToRemove.Clear();
        }
    }
}