MoonsideGames
/
encompass-cs
4
0
Fork 0
Code Issues Pull Requests Releases 7 Wiki Activity

fix style issues
continuous-integration/drone/push Build is passing Details

pull/3/head
Evan Hemsley 2020-03-20 00:09:57 -07:00
parent ffc052ded3
commit 7f89e9b4a0
31 changed files with 591 additions and 574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
encompass-cs/Attributes/DefaultWritePriority.cs
View File

@ -5,11 +5,11 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class DefaultWritePriority : Attribute public class DefaultWritePriority : Attribute
{ {
public int writePriority; public int WritePriority { get; }
public DefaultWritePriority(int writePriority) public DefaultWritePriority(int writePriority)
{ {
this.writePriority = writePriority; WritePriority = writePriority;
} }
} }
} }

4
encompass-cs/Attributes/QueryWith.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class QueryWith : Attribute public class QueryWith : Attribute
{ {
public readonly HashSet<Type> queryWithTypes = new HashSet<Type>(); public readonly HashSet<Type> QueryWithTypes = new HashSet<Type>();
public QueryWith(params Type[] queryWithTypes) public QueryWith(params Type[] queryWithTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
throw new IllegalReadTypeException("{0} must be a Component", queryWithType.Name); throw new IllegalReadTypeException("{0} must be a Component", queryWithType.Name);
} }
this.queryWithTypes.Add(queryWithType); QueryWithTypes.Add(queryWithType);
} }
} }
} }

4
encompass-cs/Attributes/QueryWithout.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class QueryWithout : Attribute public class QueryWithout : Attribute
{ {
public readonly HashSet<Type> queryWithoutTypes = new HashSet<Type>(); public readonly HashSet<Type> QueryWithoutTypes = new HashSet<Type>();
public QueryWithout(params Type[] queryWithoutTypes) public QueryWithout(params Type[] queryWithoutTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
throw new IllegalReadTypeException("{0} must be a Component", type.Name); throw new IllegalReadTypeException("{0} must be a Component", type.Name);
} }
this.queryWithoutTypes.Add(type); this.QueryWithoutTypes.Add(type);
} }
} }
} }

4
encompass-cs/Attributes/Reads.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class Reads : Attribute public class Reads : Attribute
{ {
public readonly HashSet<Type> readTypes = new HashSet<Type>(); public readonly HashSet<Type> ReadTypes = new HashSet<Type>();
public Reads(params Type[] readTypes) public Reads(params Type[] readTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
throw new IllegalReadTypeException("{0} must be a Component", readType.Name); throw new IllegalReadTypeException("{0} must be a Component", readType.Name);
} }
this.readTypes.Add(readType); this.ReadTypes.Add(readType);
} }
} }
} }

4
encompass-cs/Attributes/ReadsImmediate.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class ReadsImmediate : Attribute public class ReadsImmediate : Attribute
{ {
public readonly HashSet<Type> readImmediateTypes = new HashSet<Type>(); public readonly HashSet<Type> ReadImmediateTypes = new HashSet<Type>();
public ReadsImmediate(params Type[] readImmediateTypes) public ReadsImmediate(params Type[] readImmediateTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
throw new IllegalReadTypeException("{0} must be a Component", readImmediateType.Name); throw new IllegalReadTypeException("{0} must be a Component", readImmediateType.Name);
} }
this.readImmediateTypes.Add(readImmediateType); this.ReadImmediateTypes.Add(readImmediateType);
} }
} }
} }

4
encompass-cs/Attributes/Receives.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class Receives : Attribute public class Receives : Attribute
{ {
public readonly HashSet<Type> receiveTypes; public readonly HashSet<Type> ReceiveTypes;
public Receives(params Type[] receiveTypes) public Receives(params Type[] receiveTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
} }
} }
this.receiveTypes = new HashSet<Type>(receiveTypes); ReceiveTypes = new HashSet<Type>(receiveTypes);
} }
} }
} }

4
encompass-cs/Attributes/Sends.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class Sends : Attribute public class Sends : Attribute
{ {
public readonly HashSet<Type> sendTypes; public readonly HashSet<Type> SendTypes;
public Sends(params Type[] sendTypes) public Sends(params Type[] sendTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
} }
} }
this.sendTypes = new HashSet<Type>(sendTypes); this.SendTypes = new HashSet<Type>(sendTypes);
} }
} }
} }

10
encompass-cs/Attributes/Writes.cs
View File

@ -8,8 +8,8 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class Writes : Attribute public class Writes : Attribute
{ {
public readonly HashSet<Type> writeTypes = new HashSet<Type>(); public readonly HashSet<Type> WriteTypes = new HashSet<Type>();
public Dictionary<Type, int> priorities = new Dictionary<Type, int>(); public readonly Dictionary<Type, int> Priorities = new Dictionary<Type, int>();
public Writes(params Type[] writeTypes) public Writes(params Type[] writeTypes)
{ {
@ -21,7 +21,7 @@ namespace Encompass
throw new IllegalWriteTypeException("{0} must be a Component", writeType.Name); throw new IllegalWriteTypeException("{0} must be a Component", writeType.Name);
} }
this.writeTypes.Add(writeType); this.WriteTypes.Add(writeType);
} }
} }
@ -33,8 +33,8 @@ namespace Encompass
throw new IllegalWriteTypeException("{0} must be a Component", writeType.Name); throw new IllegalWriteTypeException("{0} must be a Component", writeType.Name);
} }
writeTypes.Add(writeType); WriteTypes.Add(writeType);
priorities.Add(writeType, priority); Priorities.Add(writeType, priority);
} }
} }
} }

4
encompass-cs/Attributes/WritesImmediate.cs
View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)] [AttributeUsage(AttributeTargets.Class)]
public class WritesImmediate : Attribute public class WritesImmediate : Attribute
{ {
public readonly HashSet<Type> writeImmediateTypes = new HashSet<Type>(); public readonly HashSet<Type> WriteImmediateTypes = new HashSet<Type>();
public WritesImmediate(params Type[] writeImmediateTypes) public WritesImmediate(params Type[] writeImmediateTypes)
{ {
@ -20,7 +20,7 @@ namespace Encompass
throw new IllegalWriteImmediateTypeException("{0} must be a Component", writeImmediateType.Name); throw new IllegalWriteImmediateTypeException("{0} must be a Component", writeImmediateType.Name);
} }
this.writeImmediateTypes.Add(writeImmediateType); this.WriteImmediateTypes.Add(writeImmediateType);
} }
} }
} }

24
encompass-cs/Collections/ComponentBitSet.cs
View File

@ -6,49 +6,49 @@ namespace Encompass
{ {
internal class ComponentBitSet internal class ComponentBitSet
{ {
Dictionary<int, BitSet512> entities = new Dictionary<int, BitSet512>(); private readonly Dictionary<int, BitSet512> _entities = new Dictionary<int, BitSet512>();
Dictionary<Type, int> TypeToIndex { get; } private readonly Dictionary<Type, int> _typeToIndex;
public ComponentBitSet(Dictionary<Type, int> typeToIndex) public ComponentBitSet(Dictionary<Type, int> typeToIndex)
{ {
TypeToIndex = typeToIndex; _typeToIndex = typeToIndex;
} }
public void Clear() public void Clear()
{ {
entities.Clear(); _entities.Clear();
} }
public void AddEntity(int entityID) public void AddEntity(int entityID)
{ {
entities.Add(entityID, BitSet512.Zero); _entities.Add(entityID, BitSet512.Zero);
} }
public void Set<TComponent>(int entityID) where TComponent : struct, IComponent public void Set<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
if (!entities.ContainsKey(entityID)) { AddEntity(entityID); } if (!_entities.ContainsKey(entityID)) { AddEntity(entityID); }
entities[entityID] = entities[entityID].Set(TypeToIndex[typeof(TComponent)]); _entities[entityID] = _entities[entityID].Set(_typeToIndex[typeof(TComponent)]);
} }
public void RemoveComponent<TComponent>(int entityID) where TComponent : struct, IComponent public void RemoveComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
if (entities.ContainsKey(entityID)) if (_entities.ContainsKey(entityID))
{ {
entities[entityID] = entities[entityID].UnSet(TypeToIndex[typeof(TComponent)]); _entities[entityID] = _entities[entityID].UnSet(_typeToIndex[typeof(TComponent)]);
} }
} }
public void RemoveEntity(int entityID) public void RemoveEntity(int entityID)
{ {
if (entities.ContainsKey(entityID)) if (_entities.ContainsKey(entityID))
{ {
entities.Remove(entityID); _entities.Remove(entityID);
} }
} }
public BitSet512 EntityBitArray(int entityID) public BitSet512 EntityBitArray(int entityID)
{ {
return entities.ContainsKey(entityID) ? entities[entityID] : BitSet512.Zero; return _entities.ContainsKey(entityID) ? _entities[entityID] : BitSet512.Zero;
} }
} }
} }

27
encompass-cs/Collections/ComponentStore.cs
View File

@ -4,14 +4,9 @@ using System.Collections.Generic;
namespace Encompass namespace Encompass
{ {
public struct MutableComponentEntityPair<TComponent> where TComponent : struct, IComponent
{
public TComponent component;
}
internal class ComponentStore internal class ComponentStore
{ {
private Dictionary<Type, TypedComponentStore> Stores = new Dictionary<Type, TypedComponentStore>(512); private Dictionary<Type, TypedComponentStore> _stores = new Dictionary<Type, TypedComponentStore>(512);
public ComponentBitSet ComponentBitSet { get; private set; } public ComponentBitSet ComponentBitSet { get; private set; }
public ComponentStore(Dictionary<Type, int> typeToIndex) public ComponentStore(Dictionary<Type, int> typeToIndex)
@ -21,7 +16,7 @@ namespace Encompass
public IEnumerable<(Type, TypedComponentStore)> StoresEnumerable() public IEnumerable<(Type, TypedComponentStore)> StoresEnumerable()
{ {
foreach (var entry in Stores) foreach (var entry in _stores)
{ {
yield return (entry.Key, entry.Value); yield return (entry.Key, entry.Value);
} }
@ -29,16 +24,16 @@ namespace Encompass
public virtual void RegisterComponentType<TComponent>() where TComponent : struct, IComponent public virtual void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
{ {
if (!Stores.ContainsKey(typeof(TComponent))) if (!_stores.ContainsKey(typeof(TComponent)))
{ {
var store = new TypedComponentStore<TComponent>(); var store = new TypedComponentStore<TComponent>();
Stores.Add(typeof(TComponent), store); _stores.Add(typeof(TComponent), store);
} }
} }
private TypedComponentStore<TComponent> Lookup<TComponent>() where TComponent : struct, IComponent private TypedComponentStore<TComponent> Lookup<TComponent>() where TComponent : struct, IComponent
{ {
return Stores[typeof(TComponent)] as TypedComponentStore<TComponent>; return _stores[typeof(TComponent)] as TypedComponentStore<TComponent>;
} }
public bool Has<TComponent>(int entityID) where TComponent : struct, IComponent public bool Has<TComponent>(int entityID) where TComponent : struct, IComponent
@ -48,7 +43,7 @@ namespace Encompass
public bool Has(Type type, int entityID) public bool Has(Type type, int entityID)
{ {
return Stores.ContainsKey(type) && Stores[type].Has(entityID); return _stores.ContainsKey(type) && _stores[type].Has(entityID);
} }
public BitSet512 EntityBitArray(int entityID) public BitSet512 EntityBitArray(int entityID)
@ -95,7 +90,7 @@ namespace Encompass
public virtual void Remove(int entityID) public virtual void Remove(int entityID)
{ {
foreach (var entry in Stores.Values) foreach (var entry in _stores.Values)
{ {
entry.ForceRemove(entityID); entry.ForceRemove(entityID);
} }
@ -109,7 +104,7 @@ namespace Encompass
public IEnumerable<(int, Type, IComponent)> AllInterfaceTyped() public IEnumerable<(int, Type, IComponent)> AllInterfaceTyped()
{ {
foreach (var store in Stores.Values) foreach (var store in _stores.Values)
{ {
foreach (var thing in store.AllInterfaceTyped()) foreach (var thing in store.AllInterfaceTyped())
{ {
@ -130,7 +125,7 @@ namespace Encompass
public virtual void ClearAllPriorities() public virtual void ClearAllPriorities()
{ {
foreach (var store in Stores.Values) foreach (var store in _stores.Values)
{ {
store.ClearPriorities(); store.ClearPriorities();
} }
@ -139,7 +134,7 @@ namespace Encompass
public virtual void ClearAll() public virtual void ClearAll()
{ {
ComponentBitSet.Clear(); ComponentBitSet.Clear();
foreach (var store in Stores.Values) foreach (var store in _stores.Values)
{ {
store.Clear(); store.Clear();
} }
@ -147,7 +142,7 @@ namespace Encompass
public void SwapWith(ComponentStore other) public void SwapWith(ComponentStore other)
{ {
(Stores, other.Stores) = (other.Stores, Stores); (_stores, other._stores) = (other._stores, _stores);
(ComponentBitSet, other.ComponentBitSet) = (other.ComponentBitSet, ComponentBitSet); (ComponentBitSet, other.ComponentBitSet) = (other.ComponentBitSet, ComponentBitSet);
} }

12
encompass-cs/Collections/MessageStore.cs
View File

@ -5,17 +5,17 @@ namespace Encompass
{ {
internal class MessageStore internal class MessageStore
{ {
private Dictionary<Type, TypedMessageStore> Stores = new Dictionary<Type, TypedMessageStore>(512); private readonly Dictionary<Type, TypedMessageStore> _stores = new Dictionary<Type, TypedMessageStore>(512);
private void RegisterMessageType<TMessage>() where TMessage : struct, IMessage private void RegisterMessageType<TMessage>() where TMessage : struct, IMessage
{ {
Stores.Add(typeof(TMessage), new TypedMessageStore<TMessage>()); _stores.Add(typeof(TMessage), new TypedMessageStore<TMessage>());
} }
private TypedMessageStore<TMessage> Lookup<TMessage>() where TMessage : struct, IMessage private TypedMessageStore<TMessage> Lookup<TMessage>() where TMessage : struct, IMessage
{ {
if (!Stores.ContainsKey(typeof(TMessage))) { RegisterMessageType<TMessage>(); } if (!_stores.ContainsKey(typeof(TMessage))) { RegisterMessageType<TMessage>(); }
return Stores[typeof(TMessage)] as TypedMessageStore<TMessage>; return _stores[typeof(TMessage)] as TypedMessageStore<TMessage>;
} }
public void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage public void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
@ -60,7 +60,7 @@ namespace Encompass
public void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta) public void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta)
{ {
foreach (var store in Stores.Values) foreach (var store in _stores.Values)
{ {
store.ProcessDelayedMessages(dilatedDelta, realtimeDelta); store.ProcessDelayedMessages(dilatedDelta, realtimeDelta);
} }
@ -68,7 +68,7 @@ namespace Encompass
public void ClearAll() public void ClearAll()
{ {
foreach (var store in Stores.Values) foreach (var store in _stores.Values)
{ {
store.Clear(); store.Clear();
} }

52
encompass-cs/Collections/TypedComponentStore.cs
View File

@ -17,17 +17,17 @@ namespace Encompass
internal class TypedComponentStore<TComponent> : TypedComponentStore where TComponent : struct, IComponent internal class TypedComponentStore<TComponent> : TypedComponentStore where TComponent : struct, IComponent
{ {
private readonly Dictionary<int, int> indices = new Dictionary<int, int>(512); private readonly Dictionary<int, int> _indices = new Dictionary<int, int>(512);
private readonly Dictionary<int, int> priorities = new Dictionary<int, int>(512); private readonly Dictionary<int, int> _priorities = new Dictionary<int, int>(512);
private TComponent[] components = new TComponent[512]; private readonly TComponent[] _components = new TComponent[512];
private readonly IDManager _idManager = new IDManager(); private readonly IDManager _idManager = new IDManager();
public override int Count { get => indices.Count; } public override int Count { get => _indices.Count; }
public unsafe ref readonly TComponent Get(int entityID) public unsafe ref readonly TComponent Get(int entityID)
{ {
if (!indices.ContainsKey(entityID)) { throw new Exceptions.NoComponentOfTypeOnEntityException("No component of type {0} exists on Entity with ID {1}", typeof(TComponent), entityID); } if (!_indices.ContainsKey(entityID)) { throw new Exceptions.NoComponentOfTypeOnEntityException("No component of type {0} exists on Entity with ID {1}", typeof(TComponent), entityID); }
ref var refVal = ref components[indices[entityID]]; ref var refVal = ref _components[_indices[entityID]];
return ref Unsafe.AsRef<TComponent>(Unsafe.AsPointer(ref refVal)); return ref Unsafe.AsRef<TComponent>(Unsafe.AsPointer(ref refVal));
} }
@ -38,10 +38,10 @@ namespace Encompass
public unsafe bool Set(int entityID, TComponent component, int priority) public unsafe bool Set(int entityID, TComponent component, int priority)
{ {
if (!priorities.ContainsKey(entityID) || priority < priorities[entityID]) if (!_priorities.ContainsKey(entityID) || priority < _priorities[entityID])
{ {
InternalSet(entityID, component); InternalSet(entityID, component);
priorities[entityID] = priority; _priorities[entityID] = priority;
return true; return true;
} }
@ -50,22 +50,22 @@ namespace Encompass
private unsafe void InternalSet(int entityID, TComponent component) private unsafe void InternalSet(int entityID, TComponent component)
{ {
if (!indices.ContainsKey(entityID)) if (!_indices.ContainsKey(entityID))
{ {
indices[entityID] = _idManager.NextID(); _indices[entityID] = _idManager.NextID();
} }
var ptr = Unsafe.AsPointer(ref component); var ptr = Unsafe.AsPointer(ref component);
components[indices[entityID]] = Unsafe.AsRef<TComponent>(ptr); _components[_indices[entityID]] = Unsafe.AsRef<TComponent>(ptr);
} }
public override bool Remove(int entityID, int priority) public override bool Remove(int entityID, int priority)
{ {
if (!priorities.ContainsKey(entityID) || priority < priorities[entityID]) if (!_priorities.ContainsKey(entityID) || priority < _priorities[entityID])
{ {
priorities[entityID] = priority; _priorities[entityID] = priority;
indices.Remove(entityID); _indices.Remove(entityID);
priorities.Remove(entityID); _priorities.Remove(entityID);
_idManager.Free(entityID); _idManager.Free(entityID);
return true; return true;
} }
@ -75,44 +75,44 @@ namespace Encompass
public override void ForceRemove(int entityID) public override void ForceRemove(int entityID)
{ {
indices.Remove(entityID); _indices.Remove(entityID);
priorities.Remove(entityID); _priorities.Remove(entityID);
_idManager.Free(entityID); _idManager.Free(entityID);
} }
public override bool Has(int entityID) public override bool Has(int entityID)
{ {
return indices.ContainsKey(entityID); return _indices.ContainsKey(entityID);
} }
public override void Clear() public override void Clear()
{ {
foreach (var entityID in indices.Keys) foreach (var entityID in _indices.Keys)
{ {
_idManager.Free(entityID); _idManager.Free(entityID);
} }
indices.Clear(); _indices.Clear();
priorities.Clear(); _priorities.Clear();
} }
public override void ClearPriorities() public override void ClearPriorities()
{ {
priorities.Clear(); _priorities.Clear();
} }
public IEnumerable<(TComponent, int)> All() public IEnumerable<(TComponent, int)> All()
{ {
foreach (var kvp in indices) foreach (var kvp in _indices)
{ {
yield return (components[kvp.Value], kvp.Key); yield return (_components[kvp.Value], kvp.Key);
} }
} }
public override IEnumerable<(int, Type, IComponent)> AllInterfaceTyped() public override IEnumerable<(int, Type, IComponent)> AllInterfaceTyped()
{ {
foreach (var kvp in indices) foreach (var kvp in _indices)
{ {
yield return (kvp.Key, typeof(TComponent), (IComponent)components[kvp.Value]); yield return (kvp.Key, typeof(TComponent), (IComponent)_components[kvp.Value]);
} }
} }
} }

48
encompass-cs/Collections/TypedMessageStore.cs
View File

@ -10,98 +10,98 @@ namespace Encompass
internal class TypedMessageStore<TMessage> : TypedMessageStore where TMessage : struct, IMessage internal class TypedMessageStore<TMessage> : TypedMessageStore where TMessage : struct, IMessage
{ {
private readonly List<TMessage> store = new List<TMessage>(128); private readonly List<TMessage> _store = new List<TMessage>(128);
private readonly List<(TMessage, double)> delayedStore = new List<(TMessage, double)>(128); private readonly List<(TMessage, double)> _delayedStore = new List<(TMessage, double)>(128);
private readonly List<(TMessage, double)> delayedStoreIgnoringTimeDilation = new List<(TMessage, double)>(128); private readonly List<(TMessage, double)> _delayedStoreIgnoringTimeDilation = new List<(TMessage, double)>(128);
private readonly Dictionary<int, List<TMessage>> entityToMessage = new Dictionary<int, List<TMessage>>(); private readonly Dictionary<int, List<TMessage>> _entityToMessage = new Dictionary<int, List<TMessage>>();
public override void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta) public override void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta)
{ {
for (int i = delayedStore.Count - 1; i >= 0; i--) for (var i = _delayedStore.Count - 1; i >= 0; i--)
{ {
var (message, time) = delayedStore[i]; var (message, time) = _delayedStore[i];
var updatedTime = time - dilatedDelta; var updatedTime = time - dilatedDelta;
if (updatedTime <= 0) if (updatedTime <= 0)
{ {
Add(message); Add(message);
delayedStore.RemoveAt(i); _delayedStore.RemoveAt(i);
} }
else else
{ {
delayedStore[i] = (message, updatedTime); _delayedStore[i] = (message, updatedTime);
} }
} }
for (int i = delayedStoreIgnoringTimeDilation.Count - 1; i >= 0; i--) for (var i = _delayedStoreIgnoringTimeDilation.Count - 1; i >= 0; i--)
{ {
var (message, time) = delayedStoreIgnoringTimeDilation[i]; var (message, time) = _delayedStoreIgnoringTimeDilation[i];
var updatedTime = time - realtimeDelta; var updatedTime = time - realtimeDelta;
if (updatedTime <= 0) if (updatedTime <= 0)
{ {
Add(message); Add(message);
delayedStoreIgnoringTimeDilation.RemoveAt(i); _delayedStoreIgnoringTimeDilation.RemoveAt(i);
} }
else else
{ {
delayedStoreIgnoringTimeDilation[i] = (message, updatedTime); _delayedStoreIgnoringTimeDilation[i] = (message, updatedTime);
} }
} }
} }
public void Add(TMessage message) public void Add(TMessage message)
{ {
store.Add(message); _store.Add(message);
if (message is IHasEntity entityMessage) if (message is IHasEntity entityMessage)
{ {
var entityID = entityMessage.Entity.ID; var entityID = entityMessage.Entity.ID;
if (!entityToMessage.ContainsKey(entityID)) { entityToMessage.Add(entityID, new List<TMessage>()); } if (!_entityToMessage.ContainsKey(entityID)) { _entityToMessage.Add(entityID, new List<TMessage>()); }
entityToMessage[entityID].Add(message); _entityToMessage[entityID].Add(message);
} }
} }
public void Add(TMessage message, double time) public void Add(TMessage message, double time)
{ {
delayedStore.Add((message, time)); _delayedStore.Add((message, time));
} }
public void AddIgnoringTimeDilation(TMessage message, double time) public void AddIgnoringTimeDilation(TMessage message, double time)
{ {
delayedStoreIgnoringTimeDilation.Add((message, time)); _delayedStoreIgnoringTimeDilation.Add((message, time));
} }
public TMessage First() public TMessage First()
{ {
return store[0]; return _store[0];
} }
public bool Any() public bool Any()
{ {
return store.Count > 0; return _store.Count > 0;
} }
public IEnumerable<TMessage> All() public IEnumerable<TMessage> All()
{ {
return store; return _store;
} }
public IEnumerable<TMessage> WithEntity(int entityID) public IEnumerable<TMessage> WithEntity(int entityID)
{ {
return entityToMessage.ContainsKey(entityID) ? entityToMessage[entityID] : System.Linq.Enumerable.Empty<TMessage>(); return _entityToMessage.ContainsKey(entityID) ? _entityToMessage[entityID] : System.Linq.Enumerable.Empty<TMessage>();
} }
public bool SomeWithEntity(int entityID) public bool SomeWithEntity(int entityID)
{ {
return entityToMessage.ContainsKey(entityID) && entityToMessage[entityID].Count > 0; return _entityToMessage.ContainsKey(entityID) && _entityToMessage[entityID].Count > 0;
} }
public override void Clear() public override void Clear()
{ {
store.Clear(); _store.Clear();
foreach (var set in entityToMessage.Values) foreach (var set in _entityToMessage.Values)
{ {
set.Clear(); set.Clear();
} }

138
encompass-cs/ComponentManager.cs
View File

@ -5,68 +5,68 @@ namespace Encompass
{ {
internal class ComponentManager internal class ComponentManager
{ {
private readonly DrawLayerManager drawLayerManager; private readonly DrawLayerManager _drawLayerManager;
private readonly ComponentStore existingComponentStore; private readonly ComponentStore _existingComponentStore;
private readonly ComponentStore immediateComponentStore; private readonly ComponentStore _immediateComponentStore;
private readonly ComponentDeltaStore replayStore; private readonly ComponentDeltaStore _replayStore;
private ComponentStore upToDateComponentStore; private readonly ComponentStore _upToDateComponentStore;
public Dictionary<Type, int> TypeToIndex { get; } public Dictionary<Type, int> TypeToIndex { get; }
private readonly HashSet<int> entitiesMarkedForRemoval = new HashSet<int>(); private readonly HashSet<int> _entitiesMarkedForRemoval = new HashSet<int>();
internal ComponentBitSet ImmediateBits { get { return immediateComponentStore.ComponentBitSet; } } internal ComponentBitSet ImmediateBits { get { return _immediateComponentStore.ComponentBitSet; } }
internal ComponentBitSet ExistingBits { get { return existingComponentStore.ComponentBitSet; } } internal ComponentBitSet ExistingBits { get { return _existingComponentStore.ComponentBitSet; } }
public ComponentManager(DrawLayerManager drawLayerManager, Dictionary<Type, int> typeToIndex) public ComponentManager(DrawLayerManager drawLayerManager, Dictionary<Type, int> typeToIndex)
{ {
this.drawLayerManager = drawLayerManager; this._drawLayerManager = drawLayerManager;
existingComponentStore = new ComponentStore(typeToIndex); _existingComponentStore = new ComponentStore(typeToIndex);
immediateComponentStore = new ComponentStore(typeToIndex); _immediateComponentStore = new ComponentStore(typeToIndex);
replayStore = new ComponentDeltaStore(typeToIndex); _replayStore = new ComponentDeltaStore(typeToIndex);
upToDateComponentStore = new ComponentStore(typeToIndex); _upToDateComponentStore = new ComponentStore(typeToIndex);
TypeToIndex = typeToIndex; TypeToIndex = typeToIndex;
} }
public void RegisterComponentType<TComponent>() where TComponent : struct, IComponent public void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
{ {
existingComponentStore.RegisterComponentType<TComponent>(); _existingComponentStore.RegisterComponentType<TComponent>();
immediateComponentStore.RegisterComponentType<TComponent>(); _immediateComponentStore.RegisterComponentType<TComponent>();
replayStore.RegisterComponentType<TComponent>(); _replayStore.RegisterComponentType<TComponent>();
upToDateComponentStore.RegisterComponentType<TComponent>(); _upToDateComponentStore.RegisterComponentType<TComponent>();
} }
internal void SetExistingComponentStore(ComponentStore componentStore) internal void SetExistingComponentStore(ComponentStore componentStore)
{ {
existingComponentStore.SwapWith(componentStore); _existingComponentStore.SwapWith(componentStore);
} }
internal void SetUpToDateComponentStore(ComponentStore componentStore) internal void SetUpToDateComponentStore(ComponentStore componentStore)
{ {
upToDateComponentStore.SwapWith(componentStore); _upToDateComponentStore.SwapWith(componentStore);
} }
internal void RegisterDrawableComponent<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent internal void RegisterDrawableComponent<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent
{ {
drawLayerManager.RegisterComponentWithLayer(entityID, component, layer); _drawLayerManager.RegisterComponentWithLayer(entityID, component, layer);
} }
internal void WriteComponents() internal void WriteComponents()
{ {
existingComponentStore.UpdateUsing(replayStore); _existingComponentStore.UpdateUsing(_replayStore);
existingComponentStore.ClearAllPriorities(); _existingComponentStore.ClearAllPriorities();
upToDateComponentStore.ClearAllPriorities(); _upToDateComponentStore.ClearAllPriorities();
immediateComponentStore.ClearAll(); _immediateComponentStore.ClearAll();
replayStore.ClearAll(); _replayStore.ClearAll();
} }
internal bool AddImmediateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent internal bool AddImmediateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
{ {
if (immediateComponentStore.Set(entityID, component, priority)) if (_immediateComponentStore.Set(entityID, component, priority))
{ {
replayStore.Set(entityID, component); _replayStore.Set(entityID, component);
upToDateComponentStore.Set(entityID, component); _upToDateComponentStore.Set(entityID, component);
return true; return true;
} }
@ -75,32 +75,32 @@ namespace Encompass
internal void AddImmediateComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent internal void AddImmediateComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
{ {
immediateComponentStore.Set(entityID, component); _immediateComponentStore.Set(entityID, component);
replayStore.Set(entityID, component); _replayStore.Set(entityID, component);
upToDateComponentStore.Set(entityID, component); _upToDateComponentStore.Set(entityID, component);
} }
internal bool UpdateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent internal bool UpdateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
{ {
var result = upToDateComponentStore.Set(entityID, component, priority); var result = _upToDateComponentStore.Set(entityID, component, priority);
if (result) if (result)
{ {
replayStore.Set(entityID, component); _replayStore.Set(entityID, component);
} }
return result; return result;
} }
internal void AddComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent internal void AddComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
{ {
upToDateComponentStore.Set(entityID, component); _upToDateComponentStore.Set(entityID, component);
replayStore.Set(entityID, component); _replayStore.Set(entityID, component);
} }
// existing or immediate reads // existing or immediate reads
internal IEnumerable<(TComponent, int)> ReadExistingAndImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent internal IEnumerable<(TComponent, int)> ReadExistingAndImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
{ {
return upToDateComponentStore.All<TComponent>(); return _upToDateComponentStore.All<TComponent>();
} }
internal (TComponent, int) ReadFirstExistingOrImmediateComponentByType<TComponent>() where TComponent : struct, IComponent internal (TComponent, int) ReadFirstExistingOrImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
@ -113,7 +113,7 @@ namespace Encompass
internal bool SomeExistingOrImmediateComponent<TComponent>() where TComponent : struct, IComponent internal bool SomeExistingOrImmediateComponent<TComponent>() where TComponent : struct, IComponent
{ {
return upToDateComponentStore.Any<TComponent>(); return _upToDateComponentStore.Any<TComponent>();
} }
// existing reads // existing reads
@ -128,14 +128,14 @@ namespace Encompass
internal bool SomeExistingComponent<TComponent>() where TComponent : struct, IComponent internal bool SomeExistingComponent<TComponent>() where TComponent : struct, IComponent
{ {
return existingComponentStore.Any<TComponent>(); return _existingComponentStore.Any<TComponent>();
} }
// immediate reads // immediate reads
internal IEnumerable<(TComponent, int)> ReadImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent internal IEnumerable<(TComponent, int)> ReadImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
{ {
return immediateComponentStore.All<TComponent>(); return _immediateComponentStore.All<TComponent>();
} }
internal (TComponent, int) ReadFirstImmediateComponentByType<TComponent>() where TComponent : struct, IComponent internal (TComponent, int) ReadFirstImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
@ -148,66 +148,66 @@ namespace Encompass
internal bool SomeImmediateComponent<TComponent>() where TComponent : struct, IComponent internal bool SomeImmediateComponent<TComponent>() where TComponent : struct, IComponent
{ {
return immediateComponentStore.Any<TComponent>(); return _immediateComponentStore.Any<TComponent>();
} }
// component getters // component getters
internal ref readonly TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent internal ref readonly TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return ref upToDateComponentStore.Get<TComponent>(entityID); return ref _upToDateComponentStore.Get<TComponent>(entityID);
} }
internal ref readonly TComponent ReadExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent internal ref readonly TComponent ReadExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return ref existingComponentStore.Get<TComponent>(entityID); return ref _existingComponentStore.Get<TComponent>(entityID);
} }
internal ref readonly TComponent ReadImmediateComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent internal ref readonly TComponent ReadImmediateComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return ref immediateComponentStore.Get<TComponent>(entityID); return ref _immediateComponentStore.Get<TComponent>(entityID);
} }
// has checkers // has checkers
internal bool HasExistingOrImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent internal bool HasExistingOrImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return upToDateComponentStore.Has<TComponent>(entityID); return _upToDateComponentStore.Has<TComponent>(entityID);
} }
internal bool HasExistingOrImmediateComponent(int entityID, Type type) internal bool HasExistingOrImmediateComponent(int entityID, Type type)
{ {
return upToDateComponentStore.Has(type, entityID); return _upToDateComponentStore.Has(type, entityID);
} }
internal bool HasExistingComponent<TComponent>(int entityID) where TComponent : struct, IComponent internal bool HasExistingComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return existingComponentStore.Has<TComponent>(entityID); return _existingComponentStore.Has<TComponent>(entityID);
} }
internal bool HasExistingComponent(int entityID, Type type) internal bool HasExistingComponent(int entityID, Type type)
{ {
return existingComponentStore.Has(type, entityID); return _existingComponentStore.Has(type, entityID);
} }
internal bool HasImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent internal bool HasImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return immediateComponentStore.Has<TComponent>(entityID); return _immediateComponentStore.Has<TComponent>(entityID);
} }
internal bool HasImmediateComponent(int entityID, Type type) internal bool HasImmediateComponent(int entityID, Type type)
{ {
return immediateComponentStore.Has(type, entityID); return _immediateComponentStore.Has(type, entityID);
} }
internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
{ {
return existingComponentStore.All<TComponent>(); return _existingComponentStore.All<TComponent>();
} }
internal IEnumerable<TComponent> GetComponentsByType<TComponent>() where TComponent : struct, IComponent internal IEnumerable<TComponent> GetComponentsByType<TComponent>() where TComponent : struct, IComponent
{ {
foreach (var pair in existingComponentStore.All<TComponent>()) foreach (var pair in _existingComponentStore.All<TComponent>())
{ {
yield return pair.Item1; yield return pair.Item1;
} }
@ -215,40 +215,40 @@ namespace Encompass
internal ref readonly TComponent GetComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent internal ref readonly TComponent GetComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return ref existingComponentStore.Get<TComponent>(entityID); return ref _existingComponentStore.Get<TComponent>(entityID);
} }
internal bool EntityHasComponentOfType<TComponent>(int entityID) where TComponent : struct, IComponent internal bool EntityHasComponentOfType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return existingComponentStore.Has<TComponent>(entityID); return _existingComponentStore.Has<TComponent>(entityID);
} }
internal void MarkAllComponentsOnEntityForRemoval(int entityID) internal void MarkAllComponentsOnEntityForRemoval(int entityID)
{ {
entitiesMarkedForRemoval.Add(entityID); _entitiesMarkedForRemoval.Add(entityID);
} }
internal void RemoveMarkedComponents() internal void RemoveMarkedComponents()
{ {
foreach (var entityID in entitiesMarkedForRemoval) foreach (var entityID in _entitiesMarkedForRemoval)
{ {
existingComponentStore.Remove(entityID); _existingComponentStore.Remove(entityID);
immediateComponentStore.Remove(entityID); _immediateComponentStore.Remove(entityID);
replayStore.Remove(entityID); _replayStore.Remove(entityID);
upToDateComponentStore.Remove(entityID); _upToDateComponentStore.Remove(entityID);
drawLayerManager.UnRegisterEntityWithLayer(entityID); _drawLayerManager.UnRegisterEntityWithLayer(entityID);
} }
entitiesMarkedForRemoval.Clear(); _entitiesMarkedForRemoval.Clear();
} }
public bool RemoveImmediate<TComponent>(int entityID, int priority) where TComponent : struct, IComponent public bool RemoveImmediate<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
{ {
if (immediateComponentStore.Remove<TComponent>(entityID, priority)) if (_immediateComponentStore.Remove<TComponent>(entityID, priority))
{ {
replayStore.Remove<TComponent>(entityID, priority); _replayStore.Remove<TComponent>(entityID, priority);
upToDateComponentStore.Remove<TComponent>(entityID, priority); _upToDateComponentStore.Remove<TComponent>(entityID, priority);
drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID); _drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
return true; return true;
} }
return false; return false;
@ -256,16 +256,16 @@ namespace Encompass
public void Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent public void Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
{ {
if (upToDateComponentStore.Remove<TComponent>(entityID, priority)) if (_upToDateComponentStore.Remove<TComponent>(entityID, priority))
{ {
replayStore.Remove<TComponent>(entityID, priority); _replayStore.Remove<TComponent>(entityID, priority);
drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID); _drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
} }
} }
public bool UpToDateEntityIsEmpty(int entityID) public bool UpToDateEntityIsEmpty(int entityID)
{ {
return upToDateComponentStore.EntityBitArray(entityID).AllFalse(); return _upToDateComponentStore.EntityBitArray(entityID).AllFalse();
} }
} }
} }

62
encompass-cs/DrawLayerManager.cs
View File

@ -7,39 +7,39 @@ namespace Encompass
{ {
internal class DrawLayerManager internal class DrawLayerManager
{ {
private readonly SortedList<int, int> layerOrder = new SortedList<int, int>(); private readonly SortedList<int, int> _layerOrder = new SortedList<int, int>();
private readonly Dictionary<int, ComponentStore> layerIndexToComponentStore = new Dictionary<int, ComponentStore>(512); private readonly Dictionary<int, ComponentStore> _layerIndexToComponentStore = new Dictionary<int, ComponentStore>(512);
private readonly Dictionary<int, HashSet<GeneralRenderer>> layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>(512); private readonly Dictionary<int, HashSet<GeneralRenderer>> _layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>(512);
private readonly Dictionary<Type, Dictionary<int, int>> typeToEntityToLayer = new Dictionary<Type, Dictionary<int, int>>(512); private readonly Dictionary<Type, Dictionary<int, int>> _typeToEntityToLayer = new Dictionary<Type, Dictionary<int, int>>(512);
private Dictionary<Type, int> typeToIndex; private readonly Dictionary<Type, int> _typeToIndex;
public IEnumerable<int> LayerOrder { get { return layerOrder.Values; } } public IEnumerable<int> LayerOrder { get { return _layerOrder.Values; } }
public DrawLayerManager(Dictionary<Type, int> typeToIndex) public DrawLayerManager(Dictionary<Type, int> typeToIndex)
{ {
this.typeToIndex = typeToIndex; _typeToIndex = typeToIndex;
RegisterDrawLayer(0); RegisterDrawLayer(0);
} }
public void RegisterDrawLayer(int layer) public void RegisterDrawLayer(int layer)
{ {
if (!layerIndexToComponentStore.ContainsKey(layer)) if (!_layerIndexToComponentStore.ContainsKey(layer))
{ {
layerOrder.Add(layer, layer); _layerOrder.Add(layer, layer);
layerIndexToGeneralRenderers.Add(layer, new HashSet<GeneralRenderer>()); _layerIndexToGeneralRenderers.Add(layer, new HashSet<GeneralRenderer>());
layerIndexToComponentStore.Add(layer, new ComponentStore(typeToIndex)); _layerIndexToComponentStore.Add(layer, new ComponentStore(_typeToIndex));
} }
} }
public void RegisterOrderedDrawable<TComponent>() where TComponent : struct, IComponent public void RegisterOrderedDrawable<TComponent>() where TComponent : struct, IComponent
{ {
if (!typeToEntityToLayer.ContainsKey(typeof(TComponent))) if (!_typeToEntityToLayer.ContainsKey(typeof(TComponent)))
{ {
typeToEntityToLayer.Add(typeof(TComponent), new Dictionary<int, int>(128)); _typeToEntityToLayer.Add(typeof(TComponent), new Dictionary<int, int>(128));
} }
foreach (var pair in layerIndexToComponentStore) foreach (var pair in _layerIndexToComponentStore)
{ {
pair.Value.RegisterComponentType<TComponent>(); pair.Value.RegisterComponentType<TComponent>();
} }
@ -48,15 +48,15 @@ namespace Encompass
public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer) public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
{ {
RegisterDrawLayer(layer); RegisterDrawLayer(layer);
var set = layerIndexToGeneralRenderers[layer]; var set = _layerIndexToGeneralRenderers[layer];
set.Add(renderer); set.Add(renderer);
} }
public void UnregisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer) public void UnregisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
{ {
if (layerIndexToGeneralRenderers.ContainsKey(layer)) if (_layerIndexToGeneralRenderers.ContainsKey(layer))
{ {
layerIndexToGeneralRenderers[layer].Remove(renderer); _layerIndexToGeneralRenderers[layer].Remove(renderer);
} }
} }
@ -68,34 +68,34 @@ namespace Encompass
public void RegisterComponentWithLayer<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent public void RegisterComponentWithLayer<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent
{ {
if (!layerIndexToComponentStore.ContainsKey(layer)) if (!_layerIndexToComponentStore.ContainsKey(layer))
{ {
throw new UndefinedLayerException("Layer {0} is not defined. Use WorldBuilder.RegisterDrawLayer to register the layer.", layer); throw new UndefinedLayerException("Layer {0} is not defined. Use WorldBuilder.RegisterDrawLayer to register the layer.", layer);
} }
if (typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID)) { UnRegisterComponentWithLayer<TComponent>(entityID); } if (_typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID)) { UnRegisterComponentWithLayer<TComponent>(entityID); }
var set = layerIndexToComponentStore[layer]; var set = _layerIndexToComponentStore[layer];
set.Set<TComponent>(entityID, component); set.Set<TComponent>(entityID, component);
typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer); _typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer);
} }
public void UnRegisterComponentWithLayer<TComponent>(int entityID) where TComponent : struct, IComponent public void UnRegisterComponentWithLayer<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
if (!typeToEntityToLayer.ContainsKey(typeof(TComponent))) { return; } if (!_typeToEntityToLayer.ContainsKey(typeof(TComponent))) { return; }
if (typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID)) if (_typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID))
{ {
var layer = typeToEntityToLayer[typeof(TComponent)][entityID]; var layer = _typeToEntityToLayer[typeof(TComponent)][entityID];
layerIndexToComponentStore[layer].ForceRemove<TComponent>(entityID); _layerIndexToComponentStore[layer].ForceRemove<TComponent>(entityID);
} }
typeToEntityToLayer[typeof(TComponent)].Remove(entityID); _typeToEntityToLayer[typeof(TComponent)].Remove(entityID);
} }
public void UnRegisterEntityWithLayer(int entityID) public void UnRegisterEntityWithLayer(int entityID)
{ {
foreach (var store in layerIndexToComponentStore.Values) foreach (var store in _layerIndexToComponentStore.Values)
{ {
store.Remove(entityID); store.Remove(entityID);
} }
@ -103,15 +103,15 @@ namespace Encompass
public IEnumerable<GeneralRenderer> GeneralRenderersByLayer(int layer) public IEnumerable<GeneralRenderer> GeneralRenderersByLayer(int layer)
{ {
return layerIndexToGeneralRenderers.ContainsKey(layer) ? return _layerIndexToGeneralRenderers.ContainsKey(layer) ?
layerIndexToGeneralRenderers[layer] : _layerIndexToGeneralRenderers[layer] :
Enumerable.Empty<GeneralRenderer>(); Enumerable.Empty<GeneralRenderer>();
} }
public IEnumerable<(int, Type, IComponent)> AllInLayer(int layer) public IEnumerable<(int, Type, IComponent)> AllInLayer(int layer)
{ {
return layerIndexToComponentStore.ContainsKey(layer) ? return _layerIndexToComponentStore.ContainsKey(layer) ?
layerIndexToComponentStore[layer].AllInterfaceTyped() : _layerIndexToComponentStore[layer].AllInterfaceTyped() :
Enumerable.Empty<(int, Type, IComponent)>(); Enumerable.Empty<(int, Type, IComponent)>();
} }
} }

260
encompass-cs/Engine.cs
View File

@ -14,104 +14,104 @@ namespace Encompass
/// </summary> /// </summary>
public abstract class Engine : IEquatable<Engine> public abstract class Engine : IEquatable<Engine>
{ {
internal Guid ID; internal Guid _id;
internal readonly HashSet<Type> readTypes = new HashSet<Type>(); internal readonly HashSet<Type> ReadTypes = new HashSet<Type>();
internal readonly HashSet<Type> readImmediateTypes = new HashSet<Type>(); internal readonly HashSet<Type> ReadImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> sendTypes = new HashSet<Type>(); internal readonly HashSet<Type> SendTypes = new HashSet<Type>();
internal readonly HashSet<Type> receiveTypes = new HashSet<Type>(); internal readonly HashSet<Type> ReceiveTypes = new HashSet<Type>();
internal readonly HashSet<Type> writeTypes = new HashSet<Type>(); internal readonly HashSet<Type> WriteTypes = new HashSet<Type>();
internal readonly HashSet<Type> writeImmediateTypes = new HashSet<Type>(); internal readonly HashSet<Type> WriteImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> queryWithTypes = new HashSet<Type>(); internal readonly HashSet<Type> QueryWithTypes = new HashSet<Type>();
internal readonly HashSet<Type> queryWithoutTypes = new HashSet<Type>(); internal readonly HashSet<Type> QueryWithoutTypes = new HashSet<Type>();
internal readonly Dictionary<Type, int> writePriorities = new Dictionary<Type, int>(); internal readonly Dictionary<Type, int> WritePriorities = new Dictionary<Type, int>();
internal readonly int defaultWritePriority = 0; internal readonly int DefaultWritePriority = 0;
/// <summary> /// <summary>
/// If false, the Engine will ignore time dilation. /// If false, the Engine will ignore time dilation.
/// </summary> /// </summary>
internal bool usesTimeDilation = true; internal bool _usesTimeDilation = true;
public bool TimeDilationActive { get => usesTimeDilation && timeManager.TimeDilationActive; } public bool TimeDilationActive { get => _usesTimeDilation && _timeManager.TimeDilationActive; }
private EntityManager entityManager; private EntityManager _entityManager;
private MessageManager messageManager; private MessageManager _messageManager;
private ComponentManager componentManager; private ComponentManager _componentManager;
private TimeManager timeManager; private TimeManager _timeManager;
private TrackingManager trackingManager; private TrackingManager _trackingManager;
private EntitySetQuery entityQuery; private EntitySetQuery _entityQuery;
private HashSet<int> _trackedEntities = new HashSet<int>(); private readonly HashSet<int> _trackedEntities = new HashSet<int>();
protected IEnumerable<Entity> TrackedEntities protected IEnumerable<Entity> TrackedEntities
{ {
get get
{ {
foreach (var entityID in _trackedEntities) foreach (var entityID in _trackedEntities)
{ {
yield return entityManager.GetEntity(entityID); yield return _entityManager.GetEntity(entityID);
} }
} }
} }
private HashSet<int> _newlyCreatedEntities = new HashSet<int>(); private readonly HashSet<int> _newlyCreatedEntities = new HashSet<int>();
protected Engine() protected Engine()
{ {
ID = Guid.NewGuid(); _id = Guid.NewGuid();
var sendsAttribute = GetType().GetCustomAttribute<Sends>(false); var sendsAttribute = GetType().GetCustomAttribute<Sends>(false);
if (sendsAttribute != null) if (sendsAttribute != null)
{ {
sendTypes = sendsAttribute.sendTypes; SendTypes = sendsAttribute.SendTypes;
} }
var activatesAttribute = GetType().GetCustomAttribute<WritesImmediate>(false); var activatesAttribute = GetType().GetCustomAttribute<WritesImmediate>(false);
if (activatesAttribute != null) if (activatesAttribute != null)
{ {
writeImmediateTypes = activatesAttribute.writeImmediateTypes; WriteImmediateTypes = activatesAttribute.WriteImmediateTypes;
} }
var defaultWritePriorityAttribute = GetType().GetCustomAttribute<DefaultWritePriority>(false); var defaultWritePriorityAttribute = GetType().GetCustomAttribute<DefaultWritePriority>(false);
if (defaultWritePriorityAttribute != null) if (defaultWritePriorityAttribute != null)
{ {
defaultWritePriority = defaultWritePriorityAttribute.writePriority; DefaultWritePriority = defaultWritePriorityAttribute.WritePriority;
} }
foreach (var writesAttribute in GetType().GetCustomAttributes<Writes>(false)) foreach (var writesAttribute in GetType().GetCustomAttributes<Writes>(false))
{ {
writeTypes.UnionWith(writesAttribute.writeTypes); WriteTypes.UnionWith(writesAttribute.WriteTypes);
writePriorities = new Dictionary<Type, int>[2] { writePriorities, writesAttribute.priorities }.SelectMany(dict => dict).ToDictionary(pair => pair.Key, pair => pair.Value); WritePriorities = new Dictionary<Type, int>[2] { WritePriorities, writesAttribute.Priorities }.SelectMany(dict => dict).ToDictionary(pair => pair.Key, pair => pair.Value);
} }
var receivesAttribute = GetType().GetCustomAttribute<Receives>(false); var receivesAttribute = GetType().GetCustomAttribute<Receives>(false);
if (receivesAttribute != null) if (receivesAttribute != null)
{ {
receiveTypes = receivesAttribute.receiveTypes; ReceiveTypes = receivesAttribute.ReceiveTypes;
} }
var readsAttribute = GetType().GetCustomAttribute<Reads>(false); var readsAttribute = GetType().GetCustomAttribute<Reads>(false);
if (readsAttribute != null) if (readsAttribute != null)
{ {
readTypes = readsAttribute.readTypes; ReadTypes = readsAttribute.ReadTypes;
} }
var readsImmediateAttribute = GetType().GetCustomAttribute<ReadsImmediate>(false); var readsImmediateAttribute = GetType().GetCustomAttribute<ReadsImmediate>(false);
if (readsImmediateAttribute != null) if (readsImmediateAttribute != null)
{ {
readImmediateTypes = readsImmediateAttribute.readImmediateTypes; ReadImmediateTypes = readsImmediateAttribute.ReadImmediateTypes;
} }
var queryWithAttribute = GetType().GetCustomAttribute<QueryWith>(false); var queryWithAttribute = GetType().GetCustomAttribute<QueryWith>(false);
if (queryWithAttribute != null) if (queryWithAttribute != null)
{ {
queryWithTypes = queryWithAttribute.queryWithTypes; QueryWithTypes = queryWithAttribute.QueryWithTypes.ToHashSet();
} }
var queryWithoutAttribute = GetType().GetCustomAttribute<QueryWithout>(false); var queryWithoutAttribute = GetType().GetCustomAttribute<QueryWithout>(false);
if (queryWithoutAttribute != null) if (queryWithoutAttribute != null)
{ {
queryWithoutTypes = queryWithoutAttribute.queryWithoutTypes; QueryWithoutTypes = queryWithoutAttribute.QueryWithoutTypes;
} }
} }
@ -127,42 +127,42 @@ namespace Encompass
public bool Equals(Engine other) public bool Equals(Engine other)
{ {
return other.ID == ID; return other._id == _id;
} }
public override int GetHashCode() public override int GetHashCode()
{ {
return ID.GetHashCode(); return HashCode.Combine(_id);
} }
internal void AssignEntityManager(EntityManager entityManager) internal void AssignEntityManager(EntityManager entityManager)
{ {
this.entityManager = entityManager; _entityManager = entityManager;
} }
internal void AssignComponentManager(ComponentManager componentManager) internal void AssignComponentManager(ComponentManager componentManager)
{ {
this.componentManager = componentManager; _componentManager = componentManager;
} }
internal void AssignMessageManager(MessageManager messageManager) internal void AssignMessageManager(MessageManager messageManager)
{ {
this.messageManager = messageManager; _messageManager = messageManager;
} }
internal void AssignTimeManager(TimeManager timeManager) internal void AssignTimeManager(TimeManager timeManager)
{ {
this.timeManager = timeManager; _timeManager = timeManager;
} }
internal void AssignTrackingManager(TrackingManager trackingManager) internal void AssignTrackingManager(TrackingManager trackingManager)
{ {
this.trackingManager = trackingManager; _trackingManager = trackingManager;
} }
internal void CheckMessageRead<TMessage>() where TMessage : struct, IMessage internal void CheckMessageRead<TMessage>() where TMessage : struct, IMessage
{ {
if (!receiveTypes.Contains(typeof(TMessage))) if (!ReceiveTypes.Contains(typeof(TMessage)))
{ {
throw new IllegalReadException("Engine {0} tried to read undeclared Message {1}", this.GetType().Name, typeof(TMessage).Name); throw new IllegalReadException("Engine {0} tried to read undeclared Message {1}", this.GetType().Name, typeof(TMessage).Name);
} }
@ -189,7 +189,7 @@ namespace Encompass
/// </summary> /// </summary>
protected Entity CreateEntity() protected Entity CreateEntity()
{ {
var entity = entityManager.CreateEntity(); var entity = _entityManager.CreateEntity();
_newlyCreatedEntities.Add(entity.ID); _newlyCreatedEntities.Add(entity.ID);
return entity; return entity;
} }
@ -199,7 +199,7 @@ namespace Encompass
/// </summary> /// </summary>
protected bool EntityExists(Entity entity) protected bool EntityExists(Entity entity)
{ {
return entityManager.EntityExists(entity.ID); return _entityManager.EntityExists(entity.ID);
} }
/// <summary> /// <summary>
@ -207,7 +207,7 @@ namespace Encompass
/// </summary> /// </summary>
protected bool EntityExists(int entityID) protected bool EntityExists(int entityID)
{ {
return entityManager.EntityExists(entityID); return _entityManager.EntityExists(entityID);
} }
/// <summary> /// <summary>
@ -215,7 +215,7 @@ namespace Encompass
/// </summary> /// </summary>
protected Entity ReadEntity<TComponent>() where TComponent : struct, IComponent protected Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
{ {
return entityManager.GetEntity(ReadComponentHelper<TComponent>().Item2); return _entityManager.GetEntity(ReadComponentHelper<TComponent>().Item2);
} }
/// <summary> /// <summary>
@ -225,7 +225,7 @@ namespace Encompass
{ {
foreach (var pair in ReadComponentsHelper<TComponent>()) foreach (var pair in ReadComponentsHelper<TComponent>())
{ {
yield return entityManager.GetEntity(pair.Item2); yield return _entityManager.GetEntity(pair.Item2);
} }
} }
@ -233,24 +233,24 @@ namespace Encompass
internal IEnumerable<TComponent> ReadComponentsFromWorld<TComponent>() where TComponent : struct, IComponent internal IEnumerable<TComponent> ReadComponentsFromWorld<TComponent>() where TComponent : struct, IComponent
{ {
return componentManager.GetComponentsByType<TComponent>(); return _componentManager.GetComponentsByType<TComponent>();
} }
private IEnumerable<(TComponent, int)> ReadComponentsHelper<TComponent>() where TComponent : struct, IComponent private IEnumerable<(TComponent, int)> ReadComponentsHelper<TComponent>() where TComponent : struct, IComponent
{ {
var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent)); var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead) if (existingRead && immediateRead)
{ {
return componentManager.ReadExistingAndImmediateComponentsByType<TComponent>(); return _componentManager.ReadExistingAndImmediateComponentsByType<TComponent>();
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.GetComponentsIncludingEntity<TComponent>(); return _componentManager.GetComponentsIncludingEntity<TComponent>();
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.ReadImmediateComponentsByType<TComponent>(); return _componentManager.ReadImmediateComponentsByType<TComponent>();
} }
else else
{ {
@ -276,25 +276,25 @@ namespace Encompass
{ {
foreach (var (component, id) in ReadComponentsHelper<TComponent>()) foreach (var (component, id) in ReadComponentsHelper<TComponent>())
{ {
yield return (component, entityManager.GetEntity(id)); yield return (component, _entityManager.GetEntity(id));
} }
} }
private (TComponent, int) ReadComponentHelper<TComponent>() where TComponent : struct, IComponent private (TComponent, int) ReadComponentHelper<TComponent>() where TComponent : struct, IComponent
{ {
var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent)); var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead) if (existingRead && immediateRead)
{ {
return componentManager.ReadFirstExistingOrImmediateComponentByType<TComponent>(); return _componentManager.ReadFirstExistingOrImmediateComponentByType<TComponent>();
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.ReadFirstExistingComponentByType<TComponent>(); return _componentManager.ReadFirstExistingComponentByType<TComponent>();
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.ReadFirstImmediateComponentByType<TComponent>(); return _componentManager.ReadFirstImmediateComponentByType<TComponent>();
} }
else else
{ {
@ -316,7 +316,7 @@ namespace Encompass
protected (TComponent, Entity) ReadComponentIncludingEntity<TComponent>() where TComponent : struct, IComponent protected (TComponent, Entity) ReadComponentIncludingEntity<TComponent>() where TComponent : struct, IComponent
{ {
var (component, id) = ReadComponentHelper<TComponent>(); var (component, id) = ReadComponentHelper<TComponent>();
return (component, entityManager.GetEntity(id)); return (component, _entityManager.GetEntity(id));
} }
/// <summary> /// <summary>
@ -324,19 +324,19 @@ namespace Encompass
/// </summary> /// </summary>
protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
{ {
var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent)); var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead) if (existingRead && immediateRead)
{ {
return componentManager.SomeExistingOrImmediateComponent<TComponent>(); return _componentManager.SomeExistingOrImmediateComponent<TComponent>();
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.SomeExistingComponent<TComponent>(); return _componentManager.SomeExistingComponent<TComponent>();
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.SomeImmediateComponent<TComponent>(); return _componentManager.SomeImmediateComponent<TComponent>();
} }
else else
{ {
@ -346,19 +346,19 @@ namespace Encompass
private ref readonly TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct, IComponent private ref readonly TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent)); var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead) if (existingRead && immediateRead)
{ {
return ref componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entityID); return ref _componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entityID);
} }
else if (existingRead) else if (existingRead)
{ {
return ref componentManager.ReadExistingComponentByEntityAndType<TComponent>(entityID); return ref _componentManager.ReadExistingComponentByEntityAndType<TComponent>(entityID);
} }
else if (immediateRead) else if (immediateRead)
{ {
return ref componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entityID); return ref _componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entityID);
} }
else else
{ {
@ -388,20 +388,20 @@ namespace Encompass
/// </exception> /// </exception>
protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent)); var existingRead = ReadTypes.Contains(typeof(TComponent));
if (immediateRead && existingRead) if (immediateRead && existingRead)
{ {
return componentManager.HasExistingOrImmediateComponent<TComponent>(entity.ID); return _componentManager.HasExistingOrImmediateComponent<TComponent>(entity.ID);
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.HasExistingComponent<TComponent>(entity.ID); return _componentManager.HasExistingComponent<TComponent>(entity.ID);
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.HasImmediateComponent<TComponent>(entity.ID); return _componentManager.HasImmediateComponent<TComponent>(entity.ID);
} }
else else
{ {
@ -417,20 +417,20 @@ namespace Encompass
/// </exception> /// </exception>
protected bool HasComponent(Entity entity, Type type) protected bool HasComponent(Entity entity, Type type)
{ {
var immediateRead = readImmediateTypes.Contains(type); var immediateRead = ReadImmediateTypes.Contains(type);
var existingRead = readTypes.Contains(type); var existingRead = ReadTypes.Contains(type);
if (immediateRead && existingRead) if (immediateRead && existingRead)
{ {
return componentManager.HasExistingOrImmediateComponent(entity.ID, type); return _componentManager.HasExistingOrImmediateComponent(entity.ID, type);
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.HasExistingComponent(entity.ID, type); return _componentManager.HasExistingComponent(entity.ID, type);
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.HasImmediateComponent(entity.ID, type); return _componentManager.HasImmediateComponent(entity.ID, type);
} }
else else
{ {
@ -446,35 +446,35 @@ namespace Encompass
/// </exception> /// </exception>
protected void SetComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent protected void SetComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
{ {
var priority = writePriorities.ContainsKey(typeof(TComponent)) ? writePriorities[typeof(TComponent)] : defaultWritePriority; var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
if (!writeTypes.Contains(typeof(TComponent))) if (!WriteTypes.Contains(typeof(TComponent)))
{ {
throw new IllegalWriteException("Engine {0} tried to update undeclared Component {1}", GetType().Name, typeof(TComponent).Name); throw new IllegalWriteException("Engine {0} tried to update undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
} }
bool written; bool written;
if (writeImmediateTypes.Contains(typeof(TComponent))) if (WriteImmediateTypes.Contains(typeof(TComponent)))
{ {
written = componentManager.AddImmediateComponent(entity.ID, component, priority); written = _componentManager.AddImmediateComponent(entity.ID, component, priority);
if (written) if (written)
{ {
trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent)); _trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
} }
} }
else else
{ {
written = componentManager.UpdateComponent(entity.ID, component, priority); written = _componentManager.UpdateComponent(entity.ID, component, priority);
} }
if (!componentManager.HasExistingComponent<TComponent>(entity.ID)) if (!_componentManager.HasExistingComponent<TComponent>(entity.ID))
{ {
trackingManager.RegisterAddition(entity.ID, typeof(TComponent)); _trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
} }
if (written && component is IDrawableComponent drawableComponent) if (written && component is IDrawableComponent drawableComponent)
{ {
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer); _componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
} }
} }
@ -491,21 +491,21 @@ namespace Encompass
throw new IllegalWriteException("AddComponent used on Entity that was not created in this context. Use SetComponent instead."); throw new IllegalWriteException("AddComponent used on Entity that was not created in this context. Use SetComponent instead.");
} }
if (writeImmediateTypes.Contains(typeof(TComponent))) if (WriteImmediateTypes.Contains(typeof(TComponent)))
{ {
componentManager.AddImmediateComponent(entity.ID, component); _componentManager.AddImmediateComponent(entity.ID, component);
trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent)); _trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
} }
else else
{ {
componentManager.AddComponent(entity.ID, component); _componentManager.AddComponent(entity.ID, component);
} }
trackingManager.RegisterAddition(entity.ID, typeof(TComponent)); _trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
if (component is IDrawableComponent drawableComponent) if (component is IDrawableComponent drawableComponent)
{ {
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer); _componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
} }
} }
@ -517,12 +517,12 @@ namespace Encompass
/// </exception> /// </exception>
protected void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage protected void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
{ {
if (!sendTypes.Contains(typeof(TMessage))) if (!SendTypes.Contains(typeof(TMessage)))
{ {
throw new IllegalSendException("Engine {0} tried to send undeclared Message {1}", GetType().Name, typeof(TMessage).Name); throw new IllegalSendException("Engine {0} tried to send undeclared Message {1}", GetType().Name, typeof(TMessage).Name);
} }
messageManager.AddMessage(message); _messageManager.AddMessage(message);
} }
/// <summary> /// <summary>
@ -531,7 +531,7 @@ namespace Encompass
/// <param name="time">The time in seconds that will elapse before the message is sent.</param> /// <param name="time">The time in seconds that will elapse before the message is sent.</param>
protected void SendMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage protected void SendMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
{ {
messageManager.AddMessage(message, time); _messageManager.AddMessage(message, time);
} }
/// <summary> /// <summary>
@ -540,7 +540,7 @@ namespace Encompass
/// <param name="time">The time in seconds that will elapse before the message is sent.</param> /// <param name="time">The time in seconds that will elapse before the message is sent.</param>
protected void SendMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage protected void SendMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
{ {
messageManager.AddMessageIgnoringTimeDilation(message, time); _messageManager.AddMessageIgnoringTimeDilation(message, time);
} }
/// <summary> /// <summary>
@ -552,7 +552,7 @@ namespace Encompass
protected IEnumerable<TMessage> ReadMessages<TMessage>() where TMessage : struct, IMessage protected IEnumerable<TMessage> ReadMessages<TMessage>() where TMessage : struct, IMessage
{ {
CheckMessageRead<TMessage>(); CheckMessageRead<TMessage>();
return messageManager.GetMessagesByType<TMessage>(); return _messageManager.GetMessagesByType<TMessage>();
} }
/// <summary> /// <summary>
@ -564,7 +564,7 @@ namespace Encompass
protected TMessage ReadMessage<TMessage>() where TMessage : struct, IMessage protected TMessage ReadMessage<TMessage>() where TMessage : struct, IMessage
{ {
CheckMessageRead<TMessage>(); CheckMessageRead<TMessage>();
return messageManager.First<TMessage>(); return _messageManager.First<TMessage>();
} }
/// <summary> /// <summary>
@ -576,7 +576,7 @@ namespace Encompass
protected bool SomeMessage<TMessage>() where TMessage : struct, IMessage protected bool SomeMessage<TMessage>() where TMessage : struct, IMessage
{ {
CheckMessageRead<TMessage>(); CheckMessageRead<TMessage>();
return messageManager.Any<TMessage>(); return _messageManager.Any<TMessage>();
} }
/// <summary> /// <summary>
@ -585,7 +585,7 @@ namespace Encompass
/// </summary> /// </summary>
protected void Destroy(Entity entity) protected void Destroy(Entity entity)
{ {
entityManager.MarkForDestroy(entity.ID); _entityManager.MarkForDestroy(entity.ID);
} }
/// <summary> /// <summary>
@ -616,28 +616,28 @@ namespace Encompass
/// </summary> /// </summary>
protected void RemoveComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected void RemoveComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
var priority = writePriorities.ContainsKey(typeof(TComponent)) ? writePriorities[typeof(TComponent)] : defaultWritePriority; var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
if (!writeTypes.Contains(typeof(TComponent))) if (!WriteTypes.Contains(typeof(TComponent)))
{ {
throw new IllegalWriteException("Engine {0} tried to remove undeclared Component {1}. Declare with Writes attribute.", GetType().Name, typeof(TComponent).Name); throw new IllegalWriteException("Engine {0} tried to remove undeclared Component {1}. Declare with Writes attribute.", GetType().Name, typeof(TComponent).Name);
} }
if (writeImmediateTypes.Contains(typeof(TComponent))) if (WriteImmediateTypes.Contains(typeof(TComponent)))
{ {
if (componentManager.RemoveImmediate<TComponent>(entity.ID, priority)) if (_componentManager.RemoveImmediate<TComponent>(entity.ID, priority))
{ {
trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent)); _trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
} }
} }
else else
{ {
componentManager.Remove<TComponent>(entity.ID, priority); _componentManager.Remove<TComponent>(entity.ID, priority);
} }
if (componentManager.HasExistingComponent<TComponent>(entity.ID)) if (_componentManager.HasExistingComponent<TComponent>(entity.ID))
{ {
trackingManager.RegisterRemoval(entity.ID, typeof(TComponent)); _trackingManager.RegisterRemoval(entity.ID, typeof(TComponent));
} }
} }
@ -652,7 +652,7 @@ namespace Encompass
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param> /// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime) protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime)
{ {
timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime); _timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime);
} }
/// <summary> /// <summary>
@ -667,7 +667,7 @@ namespace Encompass
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param> /// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime) protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime)
{ {
timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime); _timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime);
} }
/// <summary> /// <summary>
@ -682,7 +682,7 @@ namespace Encompass
/// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param> /// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction) protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{ {
timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime, easeOutFunction); _timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime, easeOutFunction);
} }
/// <summary> /// <summary>
@ -698,7 +698,7 @@ namespace Encompass
/// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param> /// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction) protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{ {
timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction); _timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction);
} }
/// <summary> /// <summary>
@ -710,7 +710,7 @@ namespace Encompass
protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
{ {
CheckMessageRead<TMessage>(); CheckMessageRead<TMessage>();
return messageManager.WithEntity<TMessage>(entity.ID); return _messageManager.WithEntity<TMessage>(entity.ID);
} }
/// <summary> /// <summary>
@ -720,7 +720,7 @@ namespace Encompass
protected TMessage ReadMessageWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity protected TMessage ReadMessageWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
{ {
CheckMessageRead<TMessage>(); CheckMessageRead<TMessage>();
return messageManager.WithEntitySingular<TMessage>(entity.ID); return _messageManager.WithEntitySingular<TMessage>(entity.ID);
} }
/// <summary> /// <summary>
@ -729,16 +729,16 @@ namespace Encompass
protected bool SomeMessageWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity protected bool SomeMessageWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
{ {
CheckMessageRead<TMessage>(); CheckMessageRead<TMessage>();
return messageManager.SomeWithEntity<TMessage>(entity.ID); return _messageManager.SomeWithEntity<TMessage>(entity.ID);
} }
internal void CheckAndUpdateTracking(int entityID) internal void CheckAndUpdateTracking(int entityID)
{ {
if (_trackedEntities.Contains(entityID) && !entityQuery.CheckEntity(entityID, componentManager.ExistingBits)) if (_trackedEntities.Contains(entityID) && !_entityQuery.CheckEntity(entityID, _componentManager.ExistingBits))
{ {
_trackedEntities.Remove(entityID); _trackedEntities.Remove(entityID);
} }
else if (!_trackedEntities.Contains(entityID) && entityQuery.CheckEntity(entityID, componentManager.ExistingBits)) else if (!_trackedEntities.Contains(entityID) && _entityQuery.CheckEntity(entityID, _componentManager.ExistingBits))
{ {
_trackedEntities.Add(entityID); _trackedEntities.Add(entityID);
} }
@ -746,11 +746,11 @@ namespace Encompass
internal void ImmediateCheckAndUpdateTracking(int entityID) internal void ImmediateCheckAndUpdateTracking(int entityID)
{ {
if (_trackedEntities.Contains(entityID) && !entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits)) if (_trackedEntities.Contains(entityID) && !_entityQuery.ImmediateCheckEntity(entityID, _componentManager.ImmediateBits, _componentManager.ExistingBits))
{ {
_trackedEntities.Remove(entityID); _trackedEntities.Remove(entityID);
} }
else if (!_trackedEntities.Contains(entityID) && entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits)) else if (!_trackedEntities.Contains(entityID) && _entityQuery.ImmediateCheckEntity(entityID, _componentManager.ImmediateBits, _componentManager.ExistingBits))
{ {
_trackedEntities.Add(entityID); _trackedEntities.Add(entityID);
} }
@ -762,30 +762,30 @@ namespace Encompass
internal void BuildEntityQuery() internal void BuildEntityQuery()
{ {
var withMask = BitSet512.Zero; var withMask = BitSet512.Zero;
foreach (var type in queryWithTypes) foreach (var type in QueryWithTypes)
{ {
withMask = withMask.Set(componentManager.TypeToIndex[type]); withMask = withMask.Set(_componentManager.TypeToIndex[type]);
} }
var withoutMask = BitSet512.Zero; var withoutMask = BitSet512.Zero;
foreach (var type in queryWithoutTypes) foreach (var type in QueryWithoutTypes)
{ {
withoutMask = withoutMask.Set(componentManager.TypeToIndex[type]); withoutMask = withoutMask.Set(_componentManager.TypeToIndex[type]);
} }
var immediateMask = BitSet512.Zero; var immediateMask = BitSet512.Zero;
foreach (var type in readImmediateTypes) foreach (var type in ReadImmediateTypes)
{ {
immediateMask = immediateMask.Set(componentManager.TypeToIndex[type]); immediateMask = immediateMask.Set(_componentManager.TypeToIndex[type]);
} }
var existingMask = BitSet512.Zero; var existingMask = BitSet512.Zero;
foreach (var type in readTypes) foreach (var type in ReadTypes)
{ {
existingMask = existingMask.Set(componentManager.TypeToIndex[type]); existingMask = existingMask.Set(_componentManager.TypeToIndex[type]);
} }
entityQuery = new EntitySetQuery( _entityQuery = new EntitySetQuery(
withMask & immediateMask, withMask & immediateMask,
withMask & existingMask, withMask & existingMask,
withoutMask & immediateMask, withoutMask & immediateMask,

4
encompass-cs/Engines/Spawner.cs
View File

@ -13,10 +13,10 @@ namespace Encompass
var readsAttribute = GetType().GetCustomAttribute<Reads>(false); var readsAttribute = GetType().GetCustomAttribute<Reads>(false);
if (readsAttribute != null) if (readsAttribute != null)
{ {
readsAttribute.readTypes.Add(typeof(TMessage)); readsAttribute.ReadTypes.Add(typeof(TMessage));
} }
receiveTypes.Add(typeof(TMessage)); ReceiveTypes.Add(typeof(TMessage));
} }
public override void Update(double dt) public override void Update(double dt)

2
encompass-cs/Entity.cs
View File

@ -37,7 +37,7 @@ namespace Encompass
public override int GetHashCode() public override int GetHashCode()
{ {
return ID.GetHashCode(); return HashCode.Combine(ID);
} }
} }
} }

40
encompass-cs/EntityManager.cs
View File

@ -5,48 +5,48 @@ namespace Encompass
{ {
internal class EntityManager internal class EntityManager
{ {
private readonly int entityCapacity; private readonly int _entityCapacity;
private readonly IDManager idManager = new IDManager(); private readonly IDManager _idManager = new IDManager();
private readonly HashSet<int> IDs = new HashSet<int>(); private readonly HashSet<int> _ids = new HashSet<int>();
private readonly HashSet<int> entitiesMarkedForDestroy = new HashSet<int>(); private readonly HashSet<int> _entitiesMarkedForDestroy = new HashSet<int>();
private readonly ComponentManager componentManager; private readonly ComponentManager _componentManager;
public IEnumerable<int> EntityIDs public IEnumerable<int> EntityIDs
{ {
get { return IDs; } get { return _ids; }
} }
public EntityManager(ComponentManager componentManager, int entityCapacity) public EntityManager(ComponentManager componentManager, int entityCapacity)
{ {
this.componentManager = componentManager; _componentManager = componentManager;
this.entityCapacity = entityCapacity; _entityCapacity = entityCapacity;
} }
private int NextID() private int NextID()
{ {
return idManager.NextID(); return _idManager.NextID();
} }
public Entity CreateEntity() public Entity CreateEntity()
{ {
if (IDs.Count < entityCapacity) if (_ids.Count < _entityCapacity)
{ {
var id = NextID(); var id = NextID();
var entity = new Entity(id); var entity = new Entity(id);
IDs.Add(id); _ids.Add(id);
return entity; return entity;
} }
else else
{ {
throw new EntityOverflowException("The number of entities has exceeded the entity capacity of {0}", entityCapacity); throw new EntityOverflowException("The number of entities has exceeded the entity capacity of {0}", _entityCapacity);
} }
} }
public bool EntityExists(int id) public bool EntityExists(int id)
{ {
return IDs.Contains(id); return _ids.Contains(id);
} }
public Entity GetEntity(int id) public Entity GetEntity(int id)
@ -61,20 +61,20 @@ namespace Encompass
public void MarkForDestroy(int entityID) public void MarkForDestroy(int entityID)
{ {
entitiesMarkedForDestroy.Add(entityID); _entitiesMarkedForDestroy.Add(entityID);
} }
public void DestroyMarkedEntities(IEnumerable<Engine> engines) public void DestroyMarkedEntities(IEnumerable<Engine> engines)
{ {
foreach (var entityID in entitiesMarkedForDestroy) foreach (var entityID in _entitiesMarkedForDestroy)
{ {
foreach (var engine in engines) { engine.RegisterDestroyedEntity(entityID); } foreach (var engine in engines) { engine.RegisterDestroyedEntity(entityID); }
componentManager.MarkAllComponentsOnEntityForRemoval(entityID); _componentManager.MarkAllComponentsOnEntityForRemoval(entityID);
IDs.Remove(entityID); _ids.Remove(entityID);
idManager.Free(entityID); _idManager.Free(entityID);
} }
entitiesMarkedForDestroy.Clear(); _entitiesMarkedForDestroy.Clear();
} }
// NOTE: this is very suboptimal // NOTE: this is very suboptimal
@ -82,7 +82,7 @@ namespace Encompass
{ {
foreach (var id in EntityIDs) foreach (var id in EntityIDs)
{ {
if (componentManager.UpToDateEntityIsEmpty(id)) if (_componentManager.UpToDateEntityIsEmpty(id))
{ {
MarkForDestroy(id); MarkForDestroy(id);
} }

14
encompass-cs/IDManager.cs
View File

@ -4,25 +4,25 @@ namespace Encompass
{ {
internal class IDManager internal class IDManager
{ {
int nextID = 0; int _nextID = 0;
private Stack<int> availableIDs = new Stack<int>(); private readonly Stack<int> _availableIDs = new Stack<int>();
public int NextID() public int NextID()
{ {
if (availableIDs.Count > 0) if (_availableIDs.Count > 0)
{ {
return availableIDs.Pop(); return _availableIDs.Pop();
} }
else else
{ {
return nextID++; return _nextID++;
} }
} }
public void Free(int ID) public void Free(int id)
{ {
availableIDs.Push(ID); _availableIDs.Push(id);
} }
} }
} }

28
encompass-cs/MessageManager.cs
View File

@ -4,69 +4,69 @@ namespace Encompass
{ {
internal class MessageManager internal class MessageManager
{ {
private readonly TimeManager timeManager; private readonly TimeManager _timeManager;
private readonly MessageStore messageStore = new MessageStore(); private readonly MessageStore _messageStore = new MessageStore();
public MessageManager(TimeManager timeManager) public MessageManager(TimeManager timeManager)
{ {
this.timeManager = timeManager; _timeManager = timeManager;
} }
internal void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage internal void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
{ {
messageStore.AddMessage(message); _messageStore.AddMessage(message);
} }
internal void AddMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage internal void AddMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
{ {
messageStore.AddMessage(message, time); _messageStore.AddMessage(message, time);
} }
internal void AddMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage internal void AddMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
{ {
messageStore.AddMessageIgnoringTimeDilation(message, time); _messageStore.AddMessageIgnoringTimeDilation(message, time);
} }
internal void ClearMessages() internal void ClearMessages()
{ {
messageStore.ClearAll(); _messageStore.ClearAll();
} }
internal void ProcessDelayedMessages(double dt) internal void ProcessDelayedMessages(double dt)
{ {
messageStore.ProcessDelayedMessages(dt * timeManager.TimeDilationFactor, dt); _messageStore.ProcessDelayedMessages(dt * _timeManager.TimeDilationFactor, dt);
} }
internal IEnumerable<TMessage> GetMessagesByType<TMessage>() where TMessage : struct, IMessage internal IEnumerable<TMessage> GetMessagesByType<TMessage>() where TMessage : struct, IMessage
{ {
return messageStore.All<TMessage>(); return _messageStore.All<TMessage>();
} }
internal bool Any<TMessage>() where TMessage : struct, IMessage internal bool Any<TMessage>() where TMessage : struct, IMessage
{ {
return messageStore.Any<TMessage>(); return _messageStore.Any<TMessage>();
} }
internal TMessage First<TMessage>() where TMessage : struct, IMessage internal TMessage First<TMessage>() where TMessage : struct, IMessage
{ {
return messageStore.First<TMessage>(); return _messageStore.First<TMessage>();
} }
internal IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity internal IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{ {
return messageStore.WithEntity<TMessage>(entityID); return _messageStore.WithEntity<TMessage>(entityID);
} }
internal TMessage WithEntitySingular<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity internal TMessage WithEntitySingular<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{ {
var enumerator = messageStore.WithEntity<TMessage>(entityID).GetEnumerator(); var enumerator = _messageStore.WithEntity<TMessage>(entityID).GetEnumerator();
enumerator.MoveNext(); enumerator.MoveNext();
return enumerator.Current; return enumerator.Current;
} }
internal bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity internal bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{ {
return messageStore.SomeWithEntity<TMessage>(entityID); return _messageStore.SomeWithEntity<TMessage>(entityID);
} }
} }
} }

28
encompass-cs/RenderManager.cs
View File

@ -5,40 +5,40 @@ namespace Encompass
{ {
internal class RenderManager internal class RenderManager
{ {
private readonly EntityManager entityManager; private readonly EntityManager _entityManager;
private readonly DrawLayerManager drawLayerManager; private readonly DrawLayerManager _drawLayerManager;
private readonly Dictionary<Type, Action<Entity, IComponent>> drawComponentTypeToOrderedRenderer = new Dictionary<Type, Action<Entity, IComponent>>(256); private readonly Dictionary<Type, Action<Entity, IComponent>> _drawComponentTypeToOrderedRenderer = new Dictionary<Type, Action<Entity, IComponent>>(256);
public RenderManager(EntityManager entityManager, DrawLayerManager drawLayerManager) public RenderManager(EntityManager entityManager, DrawLayerManager drawLayerManager)
{ {
this.entityManager = entityManager; _entityManager = entityManager;
this.drawLayerManager = drawLayerManager; _drawLayerManager = drawLayerManager;
} }
public void RegisterOrderedRenderer<TComponent>(Action<Entity, IComponent> renderAction) where TComponent : struct, IComponent public void RegisterOrderedRenderer<TComponent>(Action<Entity, IComponent> renderAction) where TComponent : struct, IComponent
{ {
drawComponentTypeToOrderedRenderer.Add(typeof(TComponent), renderAction); _drawComponentTypeToOrderedRenderer.Add(typeof(TComponent), renderAction);
drawLayerManager.RegisterOrderedDrawable<TComponent>(); _drawLayerManager.RegisterOrderedDrawable<TComponent>();
} }
public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer) public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
{ {
drawLayerManager.RegisterGeneralRendererWithLayer(renderer, layer); _drawLayerManager.RegisterGeneralRendererWithLayer(renderer, layer);
} }
public void Draw() public void Draw()
{ {
foreach (var layer in drawLayerManager.LayerOrder) foreach (var layer in _drawLayerManager.LayerOrder)
{ {
var generalRendererSet = drawLayerManager.GeneralRenderersByLayer(layer); var generalRendererSet = _drawLayerManager.GeneralRenderersByLayer(layer);
foreach (var (entityID, componentType, component) in drawLayerManager.AllInLayer(layer)) foreach (var (entityID, componentType, component) in _drawLayerManager.AllInLayer(layer))
{ {
if (drawComponentTypeToOrderedRenderer.ContainsKey(componentType)) if (_drawComponentTypeToOrderedRenderer.ContainsKey(componentType))
{ {
var internalRenderAction = drawComponentTypeToOrderedRenderer[componentType]; var internalRenderAction = _drawComponentTypeToOrderedRenderer[componentType];
internalRenderAction(entityManager.GetEntity(entityID), component); internalRenderAction(_entityManager.GetEntity(entityID), component);
} }
} }

20
encompass-cs/Renderer.cs
View File

@ -4,17 +4,17 @@ namespace Encompass
{ {
public abstract class Renderer public abstract class Renderer
{ {
internal EntityManager entityManager; internal EntityManager _entityManager;
internal ComponentManager componentManager; internal ComponentManager _componentManager;
internal void AssignEntityManager(EntityManager entityManager) internal void AssignEntityManager(EntityManager entityManager)
{ {
this.entityManager = entityManager; _entityManager = entityManager;
} }
internal void AssignComponentManager(ComponentManager componentManager) internal void AssignComponentManager(ComponentManager componentManager)
{ {
this.componentManager = componentManager; _componentManager = componentManager;
} }
protected IEnumerable<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent protected IEnumerable<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
@ -32,14 +32,14 @@ namespace Encompass
protected IEnumerable<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent protected IEnumerable<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
{ {
return componentManager.GetComponentsByType<TComponent>(); return _componentManager.GetComponentsByType<TComponent>();
} }
protected IEnumerable<(TComponent, Entity)> ReadComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent protected IEnumerable<(TComponent, Entity)> ReadComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
{ {
foreach (var (component, id) in componentManager.GetComponentsIncludingEntity<TComponent>()) foreach (var (component, id) in _componentManager.GetComponentsIncludingEntity<TComponent>())
{ {
yield return (component, entityManager.GetEntity(id)); yield return (component, _entityManager.GetEntity(id));
} }
} }
@ -59,17 +59,17 @@ namespace Encompass
protected ref readonly TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected ref readonly TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
return ref componentManager.GetComponentByEntityAndType<TComponent>(entity.ID); return ref _componentManager.GetComponentByEntityAndType<TComponent>(entity.ID);
} }
protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
return componentManager.EntityHasComponentOfType<TComponent>(entity.ID); return _componentManager.EntityHasComponentOfType<TComponent>(entity.ID);
} }
protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
{ {
return componentManager.SomeExistingComponent<TComponent>(); return _componentManager.SomeExistingComponent<TComponent>();
} }
} }
} }

49
encompass-cs/TimeDilationData.cs
View File

@ -1,35 +1,56 @@
using System;
namespace Encompass namespace Encompass
{ {
internal struct TimeDilationData internal struct TimeDilationData
{ {
public double elapsedTime; private readonly double _factor;
public double easeInTime;
public System.Func<double, double, double, double, double> easeInFunction;
public double activeTime;
public double easeOutTime;
public System.Func<double, double, double, double, double> easeOutFunction;
public double factor;
public double Factor public double Factor
{ {
get get
{ {
if (elapsedTime < easeInTime) if (ElapsedTime < EaseInTime)
{ {
return easeInFunction(elapsedTime, 1, factor - 1, easeInTime); return EaseInFunction(ElapsedTime, 1, _factor - 1, EaseInTime);
} }
else if (elapsedTime < easeInTime + activeTime) else if (ElapsedTime < EaseInTime + ActiveTime)
{ {
return factor; return _factor;
} }
else if (elapsedTime < easeInTime + activeTime + easeOutTime) else if (ElapsedTime < EaseInTime + ActiveTime + EaseOutTime)
{ {
var elapsedOutTime = elapsedTime - easeInTime - activeTime; var elapsedOutTime = ElapsedTime - EaseInTime - ActiveTime;
return easeOutFunction(elapsedOutTime, factor, 1 - factor, easeOutTime); return EaseOutFunction(elapsedOutTime, _factor, 1 - _factor, EaseOutTime);
} }
return 1; return 1;
} }
} }
public double ElapsedTime { get; set; }
public double EaseInTime { get; }
public Func<double, double, double, double, double> EaseInFunction { get; }
public double ActiveTime { get; }
public double EaseOutTime { get; }
public Func<double, double, double, double, double> EaseOutFunction { get; }
public TimeDilationData(
double factor,
double easeInTime,
Func<double, double, double, double, double> easeInfunction,
double activeTime,
double easeOutTime,
Func<double, double, double, double, double> easeOutFunction
)
{
_factor = factor;
EaseInTime = easeInTime;
EaseInFunction = easeInfunction;
ActiveTime = activeTime;
EaseOutTime = easeOutTime;
EaseOutFunction = easeOutFunction;
ElapsedTime = 0;
}
} }
} }

41
encompass-cs/TimeManager.cs
View File

@ -4,7 +4,7 @@ namespace Encompass
{ {
internal class TimeManager internal class TimeManager
{ {
private readonly List<TimeDilationData> timeDilationDatas = new List<TimeDilationData>(32); private readonly List<TimeDilationData> _timeDilationDatas = new List<TimeDilationData>(32);
private double Linear(double t, double b, double c, double d) private double Linear(double t, double b, double c, double d)
{ {
@ -15,36 +15,36 @@ namespace Encompass
{ {
get get
{ {
if (timeDilationDatas.Count == 0) { return 1; } if (_timeDilationDatas.Count == 0) { return 1; }
var average = 0.0; var average = 0.0;
foreach (var data in timeDilationDatas) foreach (var data in _timeDilationDatas)
{ {
average += data.Factor; average += data.Factor;
} }
return average / timeDilationDatas.Count; return average / _timeDilationDatas.Count;
} }
} }
public bool TimeDilationActive public bool TimeDilationActive
{ {
get => timeDilationDatas.Count != 0; get => _timeDilationDatas.Count != 0;
} }
public void Update(double dt) public void Update(double dt)
{ {
for (var i = timeDilationDatas.Count - 1; i >= 0; i--) for (var i = _timeDilationDatas.Count - 1; i >= 0; i--)
{ {
var data = timeDilationDatas[i]; var data = _timeDilationDatas[i];
data.elapsedTime += dt; data.ElapsedTime += dt;
if (data.elapsedTime > data.easeInTime + data.activeTime + data.easeOutTime) if (data.ElapsedTime > data.EaseInTime + data.ActiveTime + data.EaseOutTime)
{ {
timeDilationDatas.RemoveAt(i); _timeDilationDatas.RemoveAt(i);
} }
else else
{ {
timeDilationDatas[i] = data; _timeDilationDatas[i] = data;
} }
} }
} }
@ -66,16 +66,15 @@ namespace Encompass
public void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction) public void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{ {
timeDilationDatas.Add(new TimeDilationData _timeDilationDatas.Add(new TimeDilationData
{ (
elapsedTime = 0, factor,
easeInTime = easeInTime, easeInTime,
easeInFunction = easeInFunction, easeInFunction,
activeTime = activeTime, activeTime,
easeOutTime = easeOutTime, easeOutTime,
easeOutFunction = easeOutFunction, easeOutFunction
factor = factor ));
});
} }
} }
} }

10
encompass-cs/TrackingManager.cs
View File

@ -5,13 +5,13 @@ namespace Encompass
{ {
internal class TrackingManager internal class TrackingManager
{ {
private Dictionary<Type, HashSet<Engine>> _immediateComponentTypesToEngines = new Dictionary<Type, HashSet<Engine>>(); private readonly Dictionary<Type, HashSet<Engine>> _immediateComponentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private Dictionary<Type, HashSet<Engine>> _componentTypesToEngines = new Dictionary<Type, HashSet<Engine>>(); private readonly Dictionary<Type, HashSet<Engine>> _componentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private HashSet<(int, Type)> _additions = new HashSet<(int, Type)>(); private readonly HashSet<(int, Type)> _additions = new HashSet<(int, Type)>();
private HashSet<(int, Type)> _removals = new HashSet<(int, Type)>(); private readonly HashSet<(int, Type)> _removals = new HashSet<(int, Type)>();
private HashSet<(int, Engine)> _pairsToCheck = new HashSet<(int, Engine)>(); private readonly HashSet<(int, Engine)> _pairsToCheck = new HashSet<(int, Engine)>();
public void RegisterComponentTypeToEngine(Type type, Engine engine) public void RegisterComponentTypeToEngine(Type type, Engine engine)
{ {

14
encompass-cs/UberEngine.cs
View File

@ -7,18 +7,18 @@ namespace Encompass
{ {
internal class UberEngine : Engine internal class UberEngine : Engine
{ {
private IEnumerable<Type> _componentTypes; private readonly IEnumerable<Type> _componentTypes;
private IEnumerable<Type> _messageTypes; private readonly IEnumerable<Type> _messageTypes;
public Entity Entity { get; private set; } public Entity Entity { get; private set; }
public UberEngine(IEnumerable<Type> componentTypes, IEnumerable<Type> messageTypes) public UberEngine(IEnumerable<Type> componentTypes, IEnumerable<Type> messageTypes)
{ {
_componentTypes = componentTypes; _componentTypes = componentTypes;
_messageTypes = messageTypes; _messageTypes = messageTypes;
readTypes.UnionWith(componentTypes); ReadTypes.UnionWith(componentTypes);
writeTypes.UnionWith(componentTypes); WriteTypes.UnionWith(componentTypes);
sendTypes.UnionWith(messageTypes); SendTypes.UnionWith(messageTypes);
receiveTypes.UnionWith(messageTypes); ReceiveTypes.UnionWith(messageTypes);
} }
public void Write() public void Write()
@ -63,6 +63,8 @@ namespace Encompass
if (typeof(IHasEntity).IsAssignableFrom(type)) if (typeof(IHasEntity).IsAssignableFrom(type))
{ {
CallGenericMethod(type, "ReadMessagesWithEntity", new Type[] { typeof(Entity) }, new object[] { Entity }); CallGenericMethod(type, "ReadMessagesWithEntity", new Type[] { typeof(Entity) }, new object[] { Entity });
CallGenericMethod(type, "ReadMessageWithEntity", new Type[] { typeof(Entity) }, new object[] { Entity });
CallGenericMethod(type, "SomeMessageWithEntity", new Type[] { typeof(Entity) }, new object[] { Entity });
} }
} }
} }

2
encompass-cs/UberRenderer.cs
View File

@ -6,7 +6,7 @@ namespace Encompass
{ {
class UberRenderer : Renderer class UberRenderer : Renderer
{ {
private IEnumerable<Type> _componentTypes; private readonly IEnumerable<Type> _componentTypes;
private Entity _entity; private Entity _entity;
public UberRenderer(IEnumerable<Type> componentTypes) public UberRenderer(IEnumerable<Type> componentTypes)

52
encompass-cs/World.cs
View File

@ -7,13 +7,13 @@ namespace Encompass
/// </summary> /// </summary>
public class World public class World
{ {
private readonly List<Engine> enginesInOrder; private readonly List<Engine> _enginesInOrder;
private readonly EntityManager entityManager; private readonly EntityManager _entityManager;
private readonly ComponentManager componentManager; private readonly ComponentManager _componentManager;
private readonly TrackingManager trackingManager; private readonly TrackingManager _trackingManager;
private readonly MessageManager messageManager; private readonly MessageManager _messageManager;
private readonly TimeManager timeManager; private readonly TimeManager _timeManager;
private readonly RenderManager renderManager; private readonly RenderManager _renderManager;
internal World( internal World(
List<Engine> enginesInOrder, List<Engine> enginesInOrder,
@ -25,13 +25,13 @@ namespace Encompass
RenderManager renderManager RenderManager renderManager
) )
{ {
this.enginesInOrder = enginesInOrder; _enginesInOrder = enginesInOrder;
this.entityManager = entityManager; _entityManager = entityManager;
this.componentManager = componentManager; _componentManager = componentManager;
this.trackingManager = trackingManager; _trackingManager = trackingManager;
this.messageManager = messageManager; _messageManager = messageManager;
this.timeManager = timeManager; _timeManager = timeManager;
this.renderManager = renderManager; _renderManager = renderManager;
} }
/// <summary> /// <summary>
@ -40,15 +40,15 @@ namespace Encompass
/// <param name="dt">The time in seconds that has passed since the previous frame.</param> /// <param name="dt">The time in seconds that has passed since the previous frame.</param>
public void Update(double dt) public void Update(double dt)
{ {
trackingManager.UpdateTracking(); _trackingManager.UpdateTracking();
messageManager.ProcessDelayedMessages(dt); _messageManager.ProcessDelayedMessages(dt);
timeManager.Update(dt); _timeManager.Update(dt);
foreach (var engine in enginesInOrder) foreach (var engine in _enginesInOrder)
{ {
if (engine.usesTimeDilation) if (engine._usesTimeDilation)
{ {
engine.Update(dt * timeManager.TimeDilationFactor); engine.Update(dt * _timeManager.TimeDilationFactor);
} }
else else
{ {
@ -58,12 +58,12 @@ namespace Encompass
engine.ClearNewlyCreatedEntities(); engine.ClearNewlyCreatedEntities();
} }
messageManager.ClearMessages(); _messageManager.ClearMessages();
entityManager.PruneEmptyEntities(); _entityManager.PruneEmptyEntities();
entityManager.DestroyMarkedEntities(enginesInOrder); _entityManager.DestroyMarkedEntities(_enginesInOrder);
componentManager.RemoveMarkedComponents(); _componentManager.RemoveMarkedComponents();
componentManager.WriteComponents(); _componentManager.WriteComponents();
} }
/// <summary> /// <summary>
@ -71,7 +71,7 @@ namespace Encompass
/// </summary> /// </summary>
public void Draw() public void Draw()
{ {
renderManager.Draw(); _renderManager.Draw();
} }
} }
} }

194
encompass-cs/WorldBuilder.cs
View File

@ -18,43 +18,43 @@ namespace Encompass
/// </remarks> /// </remarks>
public class WorldBuilder public class WorldBuilder
{ {
private readonly int entityCapacity; private readonly int _entityCapacity;
private readonly List<Engine> engines = new List<Engine>(); private readonly List<Engine> _engines = new List<Engine>();
private readonly DirectedGraph<Engine, Unit> engineGraph = GraphBuilder.DirectedGraph<Engine>(); private readonly DirectedGraph<Engine, Unit> _engineGraph = GraphBuilder.DirectedGraph<Engine>();
private readonly ComponentStore startingExistingComponentStore; private readonly ComponentStore _startingExistingComponentStore;
private readonly ComponentStore startingUpToDateComponentStore; private readonly ComponentStore _startingUpToDateComponentStore;
private readonly ComponentManager componentManager; private readonly ComponentManager _componentManager;
private readonly EntityManager entityManager; private readonly EntityManager _entityManager;
private readonly MessageManager messageManager; private readonly MessageManager _messageManager;
private readonly TimeManager timeManager; private readonly TimeManager _timeManager;
private readonly DrawLayerManager drawLayerManager; private readonly DrawLayerManager _drawLayerManager;
private readonly RenderManager renderManager; private readonly RenderManager _renderManager;
private readonly TrackingManager trackingManager; private readonly TrackingManager _trackingManager;
private readonly Dictionary<Type, HashSet<Engine>> typeToReaders = new Dictionary<Type, HashSet<Engine>>(); private readonly Dictionary<Type, HashSet<Engine>> _typeToReaders = new Dictionary<Type, HashSet<Engine>>();
private readonly HashSet<Engine> senders = new HashSet<Engine>(); private readonly HashSet<Engine> _senders = new HashSet<Engine>();
private readonly HashSet<Type> componentTypesToPreload = new HashSet<Type>(); private readonly HashSet<Type> _componentTypesToPreload = new HashSet<Type>();
private readonly HashSet<Type> messageTypes = new HashSet<Type>(); private readonly HashSet<Type> _messageTypes = new HashSet<Type>();
private readonly Dictionary<Type, int> typeToIndex = new Dictionary<Type, int>(); private readonly Dictionary<Type, int> _typeToIndex = new Dictionary<Type, int>();
public WorldBuilder(int entityCapacity = 32768) public WorldBuilder(int entityCapacity = 32768)
{ {
this.entityCapacity = entityCapacity; _entityCapacity = entityCapacity;
drawLayerManager = new DrawLayerManager(typeToIndex); _drawLayerManager = new DrawLayerManager(_typeToIndex);
timeManager = new TimeManager(); _timeManager = new TimeManager();
trackingManager = new TrackingManager(); _trackingManager = new TrackingManager();
componentManager = new ComponentManager(drawLayerManager, typeToIndex); _componentManager = new ComponentManager(_drawLayerManager, _typeToIndex);
messageManager = new MessageManager(timeManager); _messageManager = new MessageManager(_timeManager);
entityManager = new EntityManager(componentManager, entityCapacity); _entityManager = new EntityManager(_componentManager, entityCapacity);
renderManager = new RenderManager(entityManager, drawLayerManager); _renderManager = new RenderManager(_entityManager, _drawLayerManager);
startingExistingComponentStore = new ComponentStore(typeToIndex); _startingExistingComponentStore = new ComponentStore(_typeToIndex);
startingUpToDateComponentStore = new ComponentStore(typeToIndex); _startingUpToDateComponentStore = new ComponentStore(_typeToIndex);
} }
/// <summary> /// <summary>
@ -62,7 +62,7 @@ namespace Encompass
/// </summary> /// </summary>
public Entity CreateEntity() public Entity CreateEntity()
{ {
return entityManager.CreateEntity(); return _entityManager.CreateEntity();
} }
/// <summary> /// <summary>
@ -70,7 +70,7 @@ namespace Encompass
/// </summary> /// </summary>
public void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage public void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
{ {
messageManager.AddMessage(message); _messageManager.AddMessage(message);
} }
/// <summary> /// <summary>
@ -78,7 +78,7 @@ namespace Encompass
/// </summary> /// </summary>
public void SendMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage public void SendMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
{ {
messageManager.AddMessage<TMessage>(message, time); _messageManager.AddMessage<TMessage>(message, time);
} }
/// <summary> /// <summary>
@ -87,31 +87,31 @@ namespace Encompass
public void SetComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent public void SetComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
{ {
RegisterComponentType<TComponent>(); RegisterComponentType<TComponent>();
startingExistingComponentStore.Set(entity.ID, component); _startingExistingComponentStore.Set(entity.ID, component);
startingUpToDateComponentStore.Set(entity.ID, component); _startingUpToDateComponentStore.Set(entity.ID, component);
if (component is IDrawableComponent drawableComponent) if (component is IDrawableComponent drawableComponent)
{ {
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer); _componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
drawLayerManager.RegisterOrderedDrawable<TComponent>(); _drawLayerManager.RegisterOrderedDrawable<TComponent>();
} }
} }
internal void RegisterComponentType<TComponent>() where TComponent : struct, IComponent internal void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
{ {
if (!typeToIndex.ContainsKey(typeof(TComponent))) if (!_typeToIndex.ContainsKey(typeof(TComponent)))
{ {
typeToIndex.Add(typeof(TComponent), typeToIndex.Count); _typeToIndex.Add(typeof(TComponent), _typeToIndex.Count);
componentTypesToPreload.Add(typeof(TComponent)); _componentTypesToPreload.Add(typeof(TComponent));
componentManager.RegisterComponentType<TComponent>(); _componentManager.RegisterComponentType<TComponent>();
startingExistingComponentStore.RegisterComponentType<TComponent>(); _startingExistingComponentStore.RegisterComponentType<TComponent>();
startingUpToDateComponentStore.RegisterComponentType<TComponent>(); _startingUpToDateComponentStore.RegisterComponentType<TComponent>();
} }
} }
internal void RegisterMessageTypes(IEnumerable<Type> types) internal void RegisterMessageTypes(IEnumerable<Type> types)
{ {
messageTypes.UnionWith(types); _messageTypes.UnionWith(types);
} }
/// <summary> /// <summary>
@ -120,21 +120,21 @@ namespace Encompass
/// <param name="engine">An instance of an Engine.</param> /// <param name="engine">An instance of an Engine.</param>
public Engine AddEngine<TEngine>(TEngine engine) where TEngine : Engine public Engine AddEngine<TEngine>(TEngine engine) where TEngine : Engine
{ {
engine.AssignEntityManager(entityManager); engine.AssignEntityManager(_entityManager);
engine.AssignComponentManager(componentManager); engine.AssignComponentManager(_componentManager);
engine.AssignMessageManager(messageManager); engine.AssignMessageManager(_messageManager);
engine.AssignTimeManager(timeManager); engine.AssignTimeManager(_timeManager);
engine.AssignTrackingManager(trackingManager); engine.AssignTrackingManager(_trackingManager);
engines.Add(engine); _engines.Add(engine);
engineGraph.AddNode(engine); _engineGraph.AddNode(engine);
var messageReceiveTypes = engine.receiveTypes; var messageReceiveTypes = engine.ReceiveTypes;
var messageSendTypes = engine.sendTypes; var messageSendTypes = engine.SendTypes;
RegisterMessageTypes(engine.receiveTypes.Union(engine.sendTypes)); RegisterMessageTypes(engine.ReceiveTypes.Union(engine.SendTypes));
foreach (var writeImmediateType in engine.writeImmediateTypes.Intersect(engine.readImmediateTypes)) foreach (var writeImmediateType in engine.WriteImmediateTypes.Intersect(engine.ReadImmediateTypes))
{ {
throw new EngineSelfCycleException("Engine {0} both writes and reads immediate Component {1}", engine.GetType().Name, writeImmediateType.Name); throw new EngineSelfCycleException("Engine {0} both writes and reads immediate Component {1}", engine.GetType().Name, writeImmediateType.Name);
} }
@ -144,28 +144,28 @@ namespace Encompass
throw new EngineSelfCycleException("Engine {0} both receives and sends Message {1}", engine.GetType().Name, messageType.Name); throw new EngineSelfCycleException("Engine {0} both receives and sends Message {1}", engine.GetType().Name, messageType.Name);
} }
if (messageSendTypes.Count > 0 || engine.writeImmediateTypes.Count > 0) if (messageSendTypes.Count > 0 || engine.WriteImmediateTypes.Count > 0)
{ {
senders.Add(engine); _senders.Add(engine);
} }
foreach (var componentType in engine.queryWithTypes.Union(engine.queryWithoutTypes)) foreach (var componentType in engine.QueryWithTypes.Union(engine.QueryWithoutTypes))
{ {
trackingManager.RegisterComponentTypeToEngine(componentType, engine); _trackingManager.RegisterComponentTypeToEngine(componentType, engine);
if (engine.readImmediateTypes.Contains(componentType)) if (engine.ReadImmediateTypes.Contains(componentType))
{ {
trackingManager.RegisterImmediateComponentTypeToEngine(componentType, engine); _trackingManager.RegisterImmediateComponentTypeToEngine(componentType, engine);
} }
} }
foreach (var receiveType in engine.receiveTypes.Union(engine.readImmediateTypes)) foreach (var receiveType in engine.ReceiveTypes.Union(engine.ReadImmediateTypes))
{ {
if (!typeToReaders.ContainsKey(receiveType)) if (!_typeToReaders.ContainsKey(receiveType))
{ {
typeToReaders.Add(receiveType, new HashSet<Engine>()); _typeToReaders.Add(receiveType, new HashSet<Engine>());
} }
typeToReaders[receiveType].Add(engine); _typeToReaders[receiveType].Add(engine);
} }
return engine; return engine;
@ -177,7 +177,7 @@ namespace Encompass
/// <param name="layer">The draw layer to register.</param> /// <param name="layer">The draw layer to register.</param>
public void RegisterDrawLayer(int layer) public void RegisterDrawLayer(int layer)
{ {
drawLayerManager.RegisterDrawLayer(layer); _drawLayerManager.RegisterDrawLayer(layer);
} }
/// <summary> /// <summary>
@ -186,9 +186,9 @@ namespace Encompass
public OrderedRenderer<TComponent> AddOrderedRenderer<TComponent>(OrderedRenderer<TComponent> renderer) where TComponent : struct, IComponent, IDrawableComponent public OrderedRenderer<TComponent> AddOrderedRenderer<TComponent>(OrderedRenderer<TComponent> renderer) where TComponent : struct, IComponent, IDrawableComponent
{ {
RegisterComponentType<TComponent>(); RegisterComponentType<TComponent>();
renderer.AssignEntityManager(entityManager); renderer.AssignEntityManager(_entityManager);
renderer.AssignComponentManager(componentManager); renderer.AssignComponentManager(_componentManager);
renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender); _renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender);
return renderer; return renderer;
} }
@ -200,29 +200,29 @@ namespace Encompass
/// <param name="layer">The layer at which the GeneralRenderer should render. Higher numbers draw over lower numbers.</param> /// <param name="layer">The layer at which the GeneralRenderer should render. Higher numbers draw over lower numbers.</param>
public TRenderer AddGeneralRenderer<TRenderer>(TRenderer renderer, int layer) where TRenderer : GeneralRenderer public TRenderer AddGeneralRenderer<TRenderer>(TRenderer renderer, int layer) where TRenderer : GeneralRenderer
{ {
renderer.AssignEntityManager(entityManager); renderer.AssignEntityManager(_entityManager);
renderer.AssignComponentManager(componentManager); renderer.AssignComponentManager(_componentManager);
renderManager.RegisterGeneralRendererWithLayer(renderer, layer); _renderManager.RegisterGeneralRendererWithLayer(renderer, layer);
return renderer; return renderer;
} }
private void BuildEngineGraph() private void BuildEngineGraph()
{ {
foreach (var senderEngine in senders) foreach (var senderEngine in _senders)
{ {
foreach (var messageType in senderEngine.sendTypes.Union(senderEngine.writeImmediateTypes)) foreach (var messageType in senderEngine.SendTypes.Union(senderEngine.WriteImmediateTypes))
{ {
if (typeToReaders.ContainsKey(messageType)) if (_typeToReaders.ContainsKey(messageType))
{ {
foreach (var readerEngine in typeToReaders[messageType]) foreach (var readerEngine in _typeToReaders[messageType])
{ {
if (senderEngine != readerEngine) if (senderEngine != readerEngine)
{ {
if (!engineGraph.Exists(senderEngine, readerEngine)) if (!_engineGraph.Exists(senderEngine, readerEngine))
{ {
engineGraph.AddEdge(senderEngine, readerEngine); _engineGraph.AddEdge(senderEngine, readerEngine);
} }
} }
} }
@ -240,9 +240,9 @@ namespace Encompass
{ {
BuildEngineGraph(); BuildEngineGraph();
if (engineGraph.Cyclic()) if (_engineGraph.Cyclic())
{ {
var cycles = engineGraph.SimpleCycles(); var cycles = _engineGraph.SimpleCycles();
var errorString = "Cycle(s) found in Engines: "; var errorString = "Cycle(s) found in Engines: ";
foreach (var cycle in cycles) foreach (var cycle in cycles)
{ {
@ -262,25 +262,25 @@ namespace Encompass
var writePriorities = new Dictionary<Type, HashSet<int>>(); var writePriorities = new Dictionary<Type, HashSet<int>>();
var writeMessageToEngines = new Dictionary<Type, List<Engine>>(); var writeMessageToEngines = new Dictionary<Type, List<Engine>>();
foreach (var engine in engines) foreach (var engine in _engines)
{ {
if (engine.GetType().GetCustomAttribute<IgnoresTimeDilation>() != null) if (engine.GetType().GetCustomAttribute<IgnoresTimeDilation>() != null)
{ {
engine.usesTimeDilation = false; engine._usesTimeDilation = false;
} }
var defaultWritePriorityAttribute = engine.GetType().GetCustomAttribute<DefaultWritePriority>(false); var defaultWritePriorityAttribute = engine.GetType().GetCustomAttribute<DefaultWritePriority>(false);
foreach (var writeType in engine.writeTypes) foreach (var writeType in engine.WriteTypes)
{ {
int? priority = null; int? priority = null;
if (engine.writePriorities.ContainsKey(writeType)) if (engine.WritePriorities.ContainsKey(writeType))
{ {
priority = engine.writePriorities[writeType]; priority = engine.WritePriorities[writeType];
} }
else if (defaultWritePriorityAttribute != null) else if (defaultWritePriorityAttribute != null)
{ {
priority = defaultWritePriorityAttribute.writePriority; priority = defaultWritePriorityAttribute.WritePriority;
} }
if (priority.HasValue) if (priority.HasValue)
@ -368,11 +368,11 @@ namespace Encompass
} }
} }
PreloadJIT(componentTypesToPreload, messageTypes); PreloadJIT(_componentTypesToPreload, _messageTypes);
var engineOrder = new List<Engine>(); var engineOrder = new List<Engine>();
foreach (var engine in engineGraph.TopologicalSort()) foreach (var engine in _engineGraph.TopologicalSort())
{ {
engineOrder.Add(engine); engineOrder.Add(engine);
engine.BuildEntityQuery(); engine.BuildEntityQuery();
@ -380,18 +380,18 @@ namespace Encompass
var world = new World( var world = new World(
engineOrder, engineOrder,
entityManager, _entityManager,
componentManager, _componentManager,
trackingManager, _trackingManager,
messageManager, _messageManager,
timeManager, _timeManager,
renderManager _renderManager
); );
componentManager.SetExistingComponentStore(startingExistingComponentStore); _componentManager.SetExistingComponentStore(_startingExistingComponentStore);
componentManager.SetUpToDateComponentStore(startingUpToDateComponentStore); _componentManager.SetUpToDateComponentStore(_startingUpToDateComponentStore);
trackingManager.InitializeTracking(entityManager.EntityIDs); _trackingManager.InitializeTracking(_entityManager.EntityIDs);
return world; return world;
} }
@ -406,10 +406,10 @@ namespace Encompass
{ {
var dummyTimeManager = new TimeManager(); var dummyTimeManager = new TimeManager();
var dummyMessageManager = new MessageManager(dummyTimeManager); var dummyMessageManager = new MessageManager(dummyTimeManager);
var dummyDrawLayerManager = new DrawLayerManager(typeToIndex); var dummyDrawLayerManager = new DrawLayerManager(_typeToIndex);
var dummyTrackingManager = new TrackingManager(); var dummyTrackingManager = new TrackingManager();
var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, typeToIndex); var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, _typeToIndex);
var dummyEntityManager = new EntityManager(dummyComponentManager, entityCapacity); var dummyEntityManager = new EntityManager(dummyComponentManager, _entityCapacity);
var dummyRenderManager = new RenderManager(dummyEntityManager, dummyDrawLayerManager); var dummyRenderManager = new RenderManager(dummyEntityManager, dummyDrawLayerManager);
var prepEngineOrder = new List<Engine>(); var prepEngineOrder = new List<Engine>();