From 1eb72874c102b6c68b3368f8b350047ea7a1d345 Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sun, 29 Dec 2019 13:54:08 -0800 Subject: [PATCH] replace entity storage with int --- encompass-cs/ComponentManager.cs | 80 +++++++++++----------- encompass-cs/Engine.cs | 87 +++++++++++++----------- encompass-cs/Engines/ComponentEmitter.cs | 2 +- encompass-cs/EntityManager.cs | 30 ++++---- encompass-cs/EntitySetQuery.cs | 10 +-- encompass-cs/Renderer.cs | 4 +- encompass-cs/TrackingManager.cs | 24 +++---- encompass-cs/WorldBuilder.cs | 4 +- 8 files changed, 125 insertions(+), 116 deletions(-) diff --git a/encompass-cs/ComponentManager.cs b/encompass-cs/ComponentManager.cs index e407408..a97096e 100644 --- a/encompass-cs/ComponentManager.cs +++ b/encompass-cs/ComponentManager.cs @@ -39,9 +39,9 @@ namespace Encompass existingComponentStore.SwapWith(componentStore); } - internal void RegisterDrawableComponent(Entity entity, TComponent component, int layer) where TComponent : struct, IComponent + internal void RegisterDrawableComponent(int entityID, TComponent component, int layer) where TComponent : struct, IComponent { - drawLayerManager.RegisterComponentWithLayer(entity.ID, component, layer); + drawLayerManager.RegisterComponentWithLayer(entityID, component, layer); } internal void WriteComponents() @@ -51,25 +51,25 @@ namespace Encompass immediateComponentStore.ClearAll(); } - internal void AddExistingComponent(Entity entity, TComponent component) where TComponent : struct, IComponent + internal void AddExistingComponent(int entityID, TComponent component) where TComponent : struct, IComponent { - upToDateComponentStore.Set(entity.ID, component); + upToDateComponentStore.Set(entityID, component); } - internal bool AddImmediateComponent(Entity entity, TComponent component, int priority) where TComponent : struct, IComponent + internal bool AddImmediateComponent(int entityID, TComponent component, int priority) where TComponent : struct, IComponent { - if (immediateComponentStore.Set(entity.ID, component, priority)) + if (immediateComponentStore.Set(entityID, component, priority)) { - upToDateComponentStore.Set(entity.ID, component); + upToDateComponentStore.Set(entityID, component); return true; } return false; } - public bool UpdateComponent(Entity entity, TComponent component, int priority) where TComponent : struct, IComponent + public bool UpdateComponent(int entityID, TComponent component, int priority) where TComponent : struct, IComponent { - return upToDateComponentStore.Set(entity.ID, component, priority); + return upToDateComponentStore.Set(entityID, component, priority); } // existing or immediate reads @@ -129,51 +129,51 @@ namespace Encompass // component getters - internal TComponent ReadImmediateOrExistingComponentByEntityAndType(Entity entity) where TComponent : struct, IComponent + internal TComponent ReadImmediateOrExistingComponentByEntityAndType(int entityID) where TComponent : struct, IComponent { - return upToDateComponentStore.Get(entity.ID); + return upToDateComponentStore.Get(entityID); } - internal TComponent ReadExistingComponentByEntityAndType(Entity entity) where TComponent : struct, IComponent + internal TComponent ReadExistingComponentByEntityAndType(int entityID) where TComponent : struct, IComponent { - return existingComponentStore.Get(entity.ID); + return existingComponentStore.Get(entityID); } - internal TComponent ReadImmediateComponentByEntityAndType(Entity entity) where TComponent : struct, IComponent + internal TComponent ReadImmediateComponentByEntityAndType(int entityID) where TComponent : struct, IComponent { - return immediateComponentStore.Get(entity.ID); + return immediateComponentStore.Get(entityID); } // has checkers - internal bool HasExistingOrImmediateComponent(Entity entity) where TComponent : struct, IComponent + internal bool HasExistingOrImmediateComponent(int entityID) where TComponent : struct, IComponent { - return upToDateComponentStore.Has(entity.ID); + return upToDateComponentStore.Has(entityID); } - internal bool HasExistingOrImmediateComponent(Entity entity, Type type) + internal bool HasExistingOrImmediateComponent(int entityID, Type type) { - return upToDateComponentStore.Has(type, entity.ID); + return upToDateComponentStore.Has(type, entityID); } - internal bool HasExistingComponent(Entity entity) where TComponent : struct, IComponent + internal bool HasExistingComponent(int entityID) where TComponent : struct, IComponent { - return existingComponentStore.Has(entity.ID); + return existingComponentStore.Has(entityID); } - internal bool HasExistingComponent(Entity entity, Type type) + internal bool HasExistingComponent(int entityID, Type type) { - return existingComponentStore.Has(type, entity.ID); + return existingComponentStore.Has(type, entityID); } - internal bool HasImmediateComponent(Entity entity) where TComponent : struct, IComponent + internal bool HasImmediateComponent(int entityID) where TComponent : struct, IComponent { - return immediateComponentStore.Has(entity.ID); + return immediateComponentStore.Has(entityID); } - internal bool HasImmediateComponent(Entity entity, Type type) + internal bool HasImmediateComponent(int entityID, Type type) { - return immediateComponentStore.Has(type, entity.ID); + return immediateComponentStore.Has(type, entityID); } internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity() where TComponent : struct, IComponent @@ -189,19 +189,19 @@ namespace Encompass } } - internal TComponent GetComponentByEntityAndType(Entity entity) where TComponent : struct, IComponent + internal TComponent GetComponentByEntityAndType(int entityID) where TComponent : struct, IComponent { - return existingComponentStore.Get(entity.ID); + return existingComponentStore.Get(entityID); } - internal bool EntityHasComponentOfType(Entity entity) where TComponent : struct, IComponent + internal bool EntityHasComponentOfType(int entityID) where TComponent : struct, IComponent { - return existingComponentStore.Has(entity.ID); + return existingComponentStore.Has(entityID); } - internal void MarkAllComponentsOnEntityForRemoval(Entity entity) + internal void MarkAllComponentsOnEntityForRemoval(int entityID) { - entitiesMarkedForRemoval.Add(entity.ID); + entitiesMarkedForRemoval.Add(entityID); } internal void RemoveMarkedComponents() @@ -216,22 +216,22 @@ namespace Encompass entitiesMarkedForRemoval.Clear(); } - public bool RemoveImmediate(Entity entity, int priority) where TComponent : struct, IComponent + public bool RemoveImmediate(int entityID, int priority) where TComponent : struct, IComponent { - if (immediateComponentStore.Remove(entity.ID, priority)) + if (immediateComponentStore.Remove(entityID, priority)) { - upToDateComponentStore.Remove(entity.ID, priority); - drawLayerManager.UnRegisterComponentWithLayer(entity.ID); + upToDateComponentStore.Remove(entityID, priority); + drawLayerManager.UnRegisterComponentWithLayer(entityID); return true; } return false; } - public void Remove(Entity entity, int priority) where TComponent : struct, IComponent + public void Remove(int entityID, int priority) where TComponent : struct, IComponent { - if (upToDateComponentStore.Remove(entity.ID, priority)) + if (upToDateComponentStore.Remove(entityID, priority)) { - drawLayerManager.UnRegisterComponentWithLayer(entity.ID); + drawLayerManager.UnRegisterComponentWithLayer(entityID); } } } diff --git a/encompass-cs/Engine.cs b/encompass-cs/Engine.cs index 356394c..ec341d7 100644 --- a/encompass-cs/Engine.cs +++ b/encompass-cs/Engine.cs @@ -41,8 +41,17 @@ namespace Encompass private EntitySetQuery entityQuery; - private HashSet _trackedEntities = new HashSet(); - protected IEnumerable TrackedEntities { get { return _trackedEntities; } } + private HashSet _trackedEntities = new HashSet(); + protected IEnumerable TrackedEntities + { + get + { + foreach (var entityID in _trackedEntities) + { + yield return entityManager.GetEntity(entityID); + } + } + } protected Engine() { @@ -313,21 +322,21 @@ namespace Encompass } } - private TComponent GetComponentHelper(Entity entity) where TComponent : struct, IComponent + private TComponent GetComponentHelper(int entityID) where TComponent : struct, IComponent { var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var existingRead = readTypes.Contains(typeof(TComponent)); if (existingRead && immediateRead) { - return componentManager.ReadImmediateOrExistingComponentByEntityAndType(entity); + return componentManager.ReadImmediateOrExistingComponentByEntityAndType(entityID); } else if (existingRead) { - return componentManager.ReadExistingComponentByEntityAndType(entity); + return componentManager.ReadExistingComponentByEntityAndType(entityID); } else if (immediateRead) { - return componentManager.ReadImmediateComponentByEntityAndType(entity); + return componentManager.ReadImmediateComponentByEntityAndType(entityID); } else { @@ -346,7 +355,7 @@ namespace Encompass /// protected TComponent GetComponent(Entity entity) where TComponent : struct, IComponent { - return GetComponentHelper(entity); + return GetComponentHelper(entity.ID); } /// @@ -362,15 +371,15 @@ namespace Encompass if (immediateRead && existingRead) { - return componentManager.HasExistingOrImmediateComponent(entity); + return componentManager.HasExistingOrImmediateComponent(entity.ID); } else if (existingRead) { - return componentManager.HasExistingComponent(entity); + return componentManager.HasExistingComponent(entity.ID); } else if (immediateRead) { - return componentManager.HasImmediateComponent(entity); + return componentManager.HasImmediateComponent(entity.ID); } else { @@ -391,15 +400,15 @@ namespace Encompass if (immediateRead && existingRead) { - return componentManager.HasExistingOrImmediateComponent(entity, type); + return componentManager.HasExistingOrImmediateComponent(entity.ID, type); } else if (existingRead) { - return componentManager.HasExistingComponent(entity, type); + return componentManager.HasExistingComponent(entity.ID, type); } else if (immediateRead) { - return componentManager.HasImmediateComponent(entity, type); + return componentManager.HasImmediateComponent(entity.ID, type); } else { @@ -425,25 +434,25 @@ namespace Encompass bool written; if (writeImmediateTypes.Contains(typeof(TComponent))) { - written = componentManager.AddImmediateComponent(entity, component, priority); + written = componentManager.AddImmediateComponent(entity.ID, component, priority); if (written) { - trackingManager.ImmediateUpdateTracking(entity, typeof(TComponent)); + trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent)); } } else { - written = componentManager.UpdateComponent(entity, component, priority); + written = componentManager.UpdateComponent(entity.ID, component, priority); } - if (!componentManager.HasExistingComponent(entity)) + if (!componentManager.HasExistingComponent(entity.ID)) { - trackingManager.RegisterAddition(entity, typeof(TComponent)); + trackingManager.RegisterAddition(entity.ID, typeof(TComponent)); } if (written && component is IDrawableComponent drawableComponent) { - componentManager.RegisterDrawableComponent(entity, component, drawableComponent.Layer); + componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer); } } @@ -481,9 +490,9 @@ namespace Encompass messageManager.AddMessageIgnoringTimeDilation(message, time); } - internal void AddExistingComponent(Entity entity, TComponent component) where TComponent : struct, IComponent + internal void AddExistingComponent(int entityID, TComponent component) where TComponent : struct, IComponent { - componentManager.AddExistingComponent(entity, component); + componentManager.AddExistingComponent(entityID, component); } /// @@ -535,7 +544,7 @@ namespace Encompass /// protected void Destroy(Entity entity) { - entityManager.MarkForDestroy(entity); + entityManager.MarkForDestroy(entity.ID); } /// @@ -575,19 +584,19 @@ namespace Encompass if (writeImmediateTypes.Contains(typeof(TComponent))) { - if (componentManager.RemoveImmediate(entity, priority)) + if (componentManager.RemoveImmediate(entity.ID, priority)) { - trackingManager.ImmediateUpdateTracking(entity, typeof(TComponent)); + trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent)); } } else { - componentManager.Remove(entity, priority); + componentManager.Remove(entity.ID, priority); } - if (componentManager.HasExistingComponent(entity)) + if (componentManager.HasExistingComponent(entity.ID)) { - trackingManager.RegisterRemoval(entity, typeof(TComponent)); + trackingManager.RegisterRemoval(entity.ID, typeof(TComponent)); } } @@ -651,27 +660,27 @@ namespace Encompass timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction); } - internal void CheckAndUpdateTracking(Entity entity) + internal void CheckAndUpdateTracking(int entityID) { - if (_trackedEntities.Contains(entity) && !entityQuery.CheckEntity(entity, componentManager.ExistingBits)) + if (_trackedEntities.Contains(entityID) && !entityQuery.CheckEntity(entityID, componentManager.ExistingBits)) { - _trackedEntities.Remove(entity); + _trackedEntities.Remove(entityID); } - else if (!_trackedEntities.Contains(entity) && entityQuery.CheckEntity(entity, componentManager.ExistingBits)) + else if (!_trackedEntities.Contains(entityID) && entityQuery.CheckEntity(entityID, componentManager.ExistingBits)) { - _trackedEntities.Add(entity); + _trackedEntities.Add(entityID); } } - internal void ImmediateCheckAndUpdateTracking(Entity entity) + internal void ImmediateCheckAndUpdateTracking(int entityID) { - if (_trackedEntities.Contains(entity) && !entityQuery.ImmediateCheckEntity(entity, componentManager.ImmediateBits, componentManager.ExistingBits)) + if (_trackedEntities.Contains(entityID) && !entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits)) { - _trackedEntities.Remove(entity); + _trackedEntities.Remove(entityID); } - else if (!_trackedEntities.Contains(entity) && entityQuery.ImmediateCheckEntity(entity, componentManager.ImmediateBits, componentManager.ExistingBits)) + else if (!_trackedEntities.Contains(entityID) && entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits)) { - _trackedEntities.Add(entity); + _trackedEntities.Add(entityID); } } @@ -713,9 +722,9 @@ namespace Encompass ); } - internal void RegisterDestroyedEntity(Entity entity) + internal void RegisterDestroyedEntity(int entityID) { - _trackedEntities.Remove(entity); + _trackedEntities.Remove(entityID); } } } diff --git a/encompass-cs/Engines/ComponentEmitter.cs b/encompass-cs/Engines/ComponentEmitter.cs index 95b61b0..2a7bd2d 100644 --- a/encompass-cs/Engines/ComponentEmitter.cs +++ b/encompass-cs/Engines/ComponentEmitter.cs @@ -6,7 +6,7 @@ { foreach (var (component, entity) in InternalRead()) { - AddExistingComponent(entity, component); + AddExistingComponent(entity.ID, component); } } } diff --git a/encompass-cs/EntityManager.cs b/encompass-cs/EntityManager.cs index f80e5cc..d9e9337 100644 --- a/encompass-cs/EntityManager.cs +++ b/encompass-cs/EntityManager.cs @@ -7,15 +7,15 @@ namespace Encompass { private readonly int entityCapacity; private readonly IDManager idManager = new IDManager(); - private readonly Dictionary IDs = new Dictionary(32768); - - private readonly HashSet entitiesMarkedForDestroy = new HashSet(); + private readonly HashSet IDs = new HashSet(); + + private readonly HashSet entitiesMarkedForDestroy = new HashSet(); private readonly ComponentManager componentManager; - public IEnumerable Entities + public IEnumerable EntityIDs { - get { return IDs.Values; } + get { return IDs; } } public EntityManager(ComponentManager componentManager, int entityCapacity) @@ -35,7 +35,7 @@ namespace Encompass { var id = NextID(); var entity = new Entity(id); - IDs.Add(id, entity); + IDs.Add(id); return entity; } else @@ -46,7 +46,7 @@ namespace Encompass public bool EntityExists(int id) { - return IDs.ContainsKey(id); + return IDs.Contains(id); } public Entity GetEntity(int id) @@ -56,22 +56,22 @@ namespace Encompass throw new Encompass.Exceptions.EntityNotFoundException("Entity with id {0} does not exist.", id); } - return IDs[id]; + return new Entity(id); } - public void MarkForDestroy(Entity entity) + public void MarkForDestroy(int entityID) { - entitiesMarkedForDestroy.Add(entity); + entitiesMarkedForDestroy.Add(entityID); } public void DestroyMarkedEntities(IEnumerable engines) { - foreach (var entity in entitiesMarkedForDestroy) + foreach (var entityID in entitiesMarkedForDestroy) { - foreach (var engine in engines) { engine.RegisterDestroyedEntity(entity); } - componentManager.MarkAllComponentsOnEntityForRemoval(entity); - IDs.Remove(entity.ID); - idManager.Free(entity.ID); + foreach (var engine in engines) { engine.RegisterDestroyedEntity(entityID); } + componentManager.MarkAllComponentsOnEntityForRemoval(entityID); + IDs.Remove(entityID); + idManager.Free(entityID); } entitiesMarkedForDestroy.Clear(); diff --git a/encompass-cs/EntitySetQuery.cs b/encompass-cs/EntitySetQuery.cs index 04c0432..978a13b 100644 --- a/encompass-cs/EntitySetQuery.cs +++ b/encompass-cs/EntitySetQuery.cs @@ -19,9 +19,9 @@ namespace Encompass NotWithMask = notWithMask; } - public bool CheckEntity(Entity entity, ComponentBitSet componentBitSet) + public bool CheckEntity(int entityID, ComponentBitSet componentBitSet) { - var existingBits = componentBitSet.EntityBitArray(entity.ID); + var existingBits = componentBitSet.EntityBitArray(entityID); var existing = (WithExistingMask & existingBits) | NotWithMask; var existingForbidden = ~(WithoutExistingMask & existingBits); @@ -29,10 +29,10 @@ namespace Encompass return (existing & existingForbidden).AllTrue(); } - public bool ImmediateCheckEntity(Entity entity, ComponentBitSet immediateBitLookup, ComponentBitSet existingBitLookup) + public bool ImmediateCheckEntity(int entityID, ComponentBitSet immediateBitLookup, ComponentBitSet existingBitLookup) { - var immediateBits = immediateBitLookup.EntityBitArray(entity.ID); - var existingBits = existingBitLookup.EntityBitArray(entity.ID); + var immediateBits = immediateBitLookup.EntityBitArray(entityID); + var existingBits = existingBitLookup.EntityBitArray(entityID); var immediate = WithImmediateMask & immediateBits; var existing = WithExistingMask & existingBits; diff --git a/encompass-cs/Renderer.cs b/encompass-cs/Renderer.cs index e0999af..3dba03c 100644 --- a/encompass-cs/Renderer.cs +++ b/encompass-cs/Renderer.cs @@ -59,12 +59,12 @@ namespace Encompass protected TComponent GetComponent(Entity entity) where TComponent : struct, IComponent { - return componentManager.GetComponentByEntityAndType(entity); + return componentManager.GetComponentByEntityAndType(entity.ID); } protected bool HasComponent(Entity entity) where TComponent : struct, IComponent { - return componentManager.EntityHasComponentOfType(entity); + return componentManager.EntityHasComponentOfType(entity.ID); } protected bool SomeComponent() where TComponent : struct, IComponent diff --git a/encompass-cs/TrackingManager.cs b/encompass-cs/TrackingManager.cs index 61600e4..c9e7830 100644 --- a/encompass-cs/TrackingManager.cs +++ b/encompass-cs/TrackingManager.cs @@ -8,10 +8,10 @@ namespace Encompass private Dictionary> _immediateComponentTypesToEngines = new Dictionary>(); private Dictionary> _componentTypesToEngines = new Dictionary>(); - private HashSet<(Entity, Type)> _additions = new HashSet<(Entity, Type)>(); - private HashSet<(Entity, Type)> _removals = new HashSet<(Entity, Type)>(); + private HashSet<(int, Type)> _additions = new HashSet<(int, Type)>(); + private HashSet<(int, Type)> _removals = new HashSet<(int, Type)>(); - private HashSet<(Entity, Engine)> _pairsToCheck = new HashSet<(Entity, Engine)>(); + private HashSet<(int, Engine)> _pairsToCheck = new HashSet<(int, Engine)>(); public void RegisterComponentTypeToEngine(Type type, Engine engine) { @@ -25,37 +25,37 @@ namespace Encompass _immediateComponentTypesToEngines[type].Add(engine); } - public void RegisterAddition(Entity entity, Type type) + public void RegisterAddition(int entityID, Type type) { - _additions.Add((entity, type)); + _additions.Add((entityID, type)); } - public void RegisterRemoval(Entity entity, Type type) + public void RegisterRemoval(int entityID, Type type) { - _removals.Add((entity, type)); + _removals.Add((entityID, type)); } - public void InitializeTracking(IEnumerable entities) + public void InitializeTracking(IEnumerable entityIDs) { - foreach (var entity in entities) + foreach (var entityID in entityIDs) { foreach (var engineSet in _componentTypesToEngines.Values) { foreach (var engine in engineSet) { - engine.CheckAndUpdateTracking(entity); + engine.CheckAndUpdateTracking(entityID); } } } } - public void ImmediateUpdateTracking(Entity entity, Type componentType) + public void ImmediateUpdateTracking(int entityID, Type componentType) { if (_immediateComponentTypesToEngines.ContainsKey(componentType)) { foreach (var engine in _componentTypesToEngines[componentType]) { - engine.ImmediateCheckAndUpdateTracking(entity); + engine.ImmediateCheckAndUpdateTracking(entityID); } } } diff --git a/encompass-cs/WorldBuilder.cs b/encompass-cs/WorldBuilder.cs index 35fdb5d..16b9ff8 100644 --- a/encompass-cs/WorldBuilder.cs +++ b/encompass-cs/WorldBuilder.cs @@ -94,7 +94,7 @@ namespace Encompass if (component is IDrawableComponent drawableComponent) { - componentManager.RegisterDrawableComponent(entity, component, drawableComponent.Layer); + componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer); drawLayerManager.RegisterOrderedDrawable(); } } @@ -397,7 +397,7 @@ namespace Encompass componentManager.SetComponentStore(startingComponentStoreForComponentManager); - trackingManager.InitializeTracking(entityManager.Entities); + trackingManager.InitializeTracking(entityManager.EntityIDs); return world; }