encompass-cs/encompass-cs/Collections/ComponentStore.cs

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

namespace Encompass
{
    internal class ComponentStore
    {
        private Dictionary<Type, TypedComponentStore> Stores = new Dictionary<Type, TypedComponentStore>(512);
        public ComponentBitSet ComponentBitSet { get; private set; }

        public ComponentStore(Dictionary<Type, int> typeToIndex)
        {
            ComponentBitSet = new ComponentBitSet(typeToIndex);
        }

        public IEnumerable<(Type, TypedComponentStore)> StoresEnumerable()
        {
            foreach (var entry in Stores)
            {
                yield return (entry.Key, entry.Value);
            }
        }

        public void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
        {
            if (!Stores.ContainsKey(typeof(TComponent)))
            {
                var store = new TypedComponentStore<TComponent>();
                Stores.Add(typeof(TComponent), store);
            }
        }

        private TypedComponentStore<TComponent> Lookup<TComponent>() where TComponent : struct, IComponent
        {
            //RegisterComponentType<TComponent>();
            return Stores[typeof(TComponent)] as TypedComponentStore<TComponent>;
        }

        public bool Has<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return Lookup<TComponent>().Has(entityID);
        }

        public bool Has(Type type, int entityID)
        {
            return Stores.ContainsKey(type) && Stores[type].Has(entityID);
        }

        public BitSet512 EntityBitArray(int entityID)
        {
            return ComponentBitSet.EntityBitArray(entityID);
        }

        public TComponent Get<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            return Lookup<TComponent>().Get(entityID);
        }

        public void Set<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
        {
            Lookup<TComponent>().Set(entityID, component);
            ComponentBitSet.Set<TComponent>(entityID);
        }

        public bool Set<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
        {
            if (Lookup<TComponent>().Set(entityID, component, priority))
            {
                ComponentBitSet.Set<TComponent>(entityID);
                return true;
            }
            return false;
        }

        public bool Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
        {
            if (Lookup<TComponent>().Remove(entityID, priority))
            {
                ComponentBitSet.RemoveComponent<TComponent>(entityID);
                return true;
            }
            return false;
        }

        public void ForceRemove<TComponent>(int entityID) where TComponent : struct, IComponent
        {
            Lookup<TComponent>().ForceRemove(entityID);
        }

        public void Remove(int entityID)
        {
            foreach (var entry in Stores.Values)
            {
                entry.ForceRemove(entityID);
            }
            ComponentBitSet.RemoveEntity(entityID);
        }

        public bool Any<TComponent>() where TComponent : struct, IComponent
        {
            return Lookup<TComponent>().Count > 0;
        }

        public IEnumerable<(int, Type, IComponent)> AllInterfaceTyped()
        {
            foreach (var store in Stores.Values)
            {
                foreach (var thing in store.AllInterfaceTyped())
                {
                    yield return thing;
                }
            }
        }

        public IEnumerable<(TComponent, int)> All<TComponent>() where TComponent : struct, IComponent
        {
            return Lookup<TComponent>().All();
        }

        public void Clear<TComponent>() where TComponent : struct, IComponent
        {
            Lookup<TComponent>().Clear();
        }

        public void ClearAll()
        {
            ComponentBitSet.Clear();
            foreach (var store in Stores.Values)
            {
                store.Clear();
            }
        }

        public void SwapWith(ComponentStore other)
        {
            (Stores, other.Stores) = (other.Stores, Stores);
            (ComponentBitSet, other.ComponentBitSet) = (other.ComponentBitSet, ComponentBitSet);
        }
    }
}