fix component remove also removing priority

encompass-cs/Attributes/Adds.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+
+namespace Encompass
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class Adds : Attribute
+    {
+        public readonly HashSet<Type> addTypes;
+
+        public Adds(params Type[] addTypes)
+        {
+            this.addTypes = new HashSet<Type>(addTypes);
+        }
+    }
+}

encompass-cs/Attributes/Receives.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using Encompass.Exceptions;
 
 namespace Encompass
 {
@@ -12,15 +10,6 @@ namespace Encompass
 
         public Receives(params Type[] receiveTypes)
         {
-            foreach (var receiveType in receiveTypes)
-            {
-                var isMessage = receiveType.GetInterfaces().Contains(typeof(IMessage));
-                if (!isMessage)
-                {
-                    throw new IllegalSendTypeException("{0} must be a Message", receiveType.Name);
-                }
-            }
-
             ReceiveTypes = new HashSet<Type>(receiveTypes);
         }
     }

encompass-cs/Attributes/Sends.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using Encompass.Exceptions;
 
 namespace Encompass
 {
@@ -12,15 +10,6 @@ namespace Encompass
 
         public Sends(params Type[] sendTypes)
         {
-            foreach (var sendType in sendTypes)
-            {
-                var isMessage = sendType.GetInterfaces().Contains(typeof(IMessage));
-                if (!isMessage)
-                {
-                    throw new IllegalSendTypeException("{0} must be a Message", sendType.Name);
-                }
-            }
-
             this.SendTypes = new HashSet<Type>(sendTypes);
         }
     }

encompass-cs/Collections/MessageStore.cs

@@ -8,60 +8,60 @@ namespace Encompass
     {
         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
         {
             _stores.Add(typeof(TMessage), new TypedMessageStore<TMessage>());
         }
 
-        private TypedMessageStore<TMessage> Lookup<TMessage>() where TMessage : struct, IMessage
+        private TypedMessageStore<TMessage> Lookup<TMessage>() where TMessage : struct
         {
             if (!_stores.ContainsKey(typeof(TMessage))) { RegisterMessageType<TMessage>(); }
             return _stores[typeof(TMessage)] as TypedMessageStore<TMessage>;
         }
 
-        public void AddMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
+        public void AddMessage<TMessage>(in TMessage message) where TMessage : struct
         {
             Lookup<TMessage>().Add(message);
         }
 
-        public void AddMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        public void AddMessage<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             Lookup<TMessage>().Add(message, time);
         }
 
-        public void AddMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        public void AddMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             Lookup<TMessage>().AddIgnoringTimeDilation(message, time);
         }
 
-        public ref readonly TMessage First<TMessage>() where TMessage : struct, IMessage
+        public ref readonly TMessage First<TMessage>() where TMessage : struct
         {
             if (!Any<TMessage>()) { throw new NoMessageOfTypeException("No Message of type {0} exists", typeof(TMessage).Name); }
 
             return ref Lookup<TMessage>().First();
         }
 
-        public ReadOnlySpan<TMessage> All<TMessage>() where TMessage : struct, IMessage
+        public ReadOnlySpan<TMessage> All<TMessage>() where TMessage : struct
         {
             return Lookup<TMessage>().All();
         }
 
-        public bool Any<TMessage>() where TMessage : struct, IMessage
+        public bool Any<TMessage>() where TMessage : struct
         {
             return Lookup<TMessage>().Any();
         }
 
-        public IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
+        public IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IHasEntity
         {
             return Lookup<TMessage>().WithEntity(entityID);
         }
 
-        public ref readonly TMessage FirstWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage
+        public ref readonly TMessage FirstWithEntity<TMessage>(int entityID) where TMessage : struct
         {
             return ref Lookup<TMessage>().FirstWithEntity(entityID);
         }
 
-        public bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
+        public bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IHasEntity
         {
             return Lookup<TMessage>().SomeWithEntity(entityID);
         }

encompass-cs/Collections/TypedComponentStore.cs

@@ -78,8 +78,8 @@ namespace Encompass
         {
             if (!_priorities.ContainsKey(entityID) || priority <= _priorities[entityID]) // if priorities are equal that means it's the same engine
             {
-                _priorities[entityID] = priority;
                 ForceRemove(entityID);
+                _priorities[entityID] = priority;
                 return true;
             }
 
@@ -92,7 +92,6 @@ namespace Encompass
             {
                 var storageIndex = _entityIDToStorageIndex[entityID];
                 _entityIDToStorageIndex.Remove(entityID);
-                _priorities.Remove(entityID);
 
                 // move a component into the hole to maintain contiguous memory
                 if (_nextID > 1 && storageIndex != _nextID - 1)

encompass-cs/Collections/TypedMessageStore.cs

@@ -9,7 +9,7 @@ namespace Encompass
         public abstract void Clear();
     }
 
-    internal class TypedMessageStore<TMessage> : TypedMessageStore where TMessage : struct, IMessage
+    internal class TypedMessageStore<TMessage> : TypedMessageStore where TMessage : struct
     {
         // messages are placed in a contiguous region
         // so we can return the collection as a Span

encompass-cs/ComponentManager.cs

@@ -5,8 +5,6 @@ namespace Encompass
 {
     internal class ComponentManager
     {
-        private readonly DrawLayerManager _drawLayerManager;
-
         private readonly ComponentStore _existingComponentStore;
         private readonly ComponentStore _immediateComponentStore;
         private readonly ComponentDeltaStore _replayStore;
@@ -19,9 +17,8 @@ namespace Encompass
         internal ComponentBitSet ImmediateBits { get { return _immediateComponentStore.ComponentBitSet; } }
         internal ComponentBitSet ExistingBits { get { return _existingComponentStore.ComponentBitSet; } }
 
-        public ComponentManager(DrawLayerManager drawLayerManager, Dictionary<Type, int> typeToIndex)
+        public ComponentManager(Dictionary<Type, int> typeToIndex)
         {
-            this._drawLayerManager = drawLayerManager;
             _existingComponentStore = new ComponentStore(typeToIndex);
             _immediateComponentStore = new ComponentStore(typeToIndex);
             _replayStore = new ComponentDeltaStore(typeToIndex);
@@ -47,11 +44,6 @@ namespace Encompass
             _upToDateComponentStore.SwapWith(componentStore);
         }
 
-        internal void RegisterDrawableComponent<TComponent>(int entityID, int layer) where TComponent : struct
-        {
-            _drawLayerManager.RegisterComponentWithLayer<TComponent>(entityID, layer);
-        }
-
         internal void WriteComponents()
         {
             _existingComponentStore.UpdateUsing(_replayStore);
@@ -264,7 +256,6 @@ namespace Encompass
                 _immediateComponentStore.Remove(entityID);
                 _replayStore.Remove(entityID);
                 _upToDateComponentStore.Remove(entityID);
-                _drawLayerManager.UnRegisterEntityWithLayer(entityID);
             }
 
             _entitiesMarkedForRemoval.Clear();
@@ -276,7 +267,6 @@ namespace Encompass
             {
                 _replayStore.Remove<TComponent>(entityID, priority);
                 _upToDateComponentStore.Remove<TComponent>(entityID, priority);
-                _drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
                 return true;
             }
             return false;
@@ -287,7 +277,6 @@ namespace Encompass
             if (_upToDateComponentStore.Remove<TComponent>(entityID, priority))
             {
                 _replayStore.Remove<TComponent>(entityID, priority);
-                _drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
             }
         }
 

encompass-cs/DrawLayerManager.cs

@@ -1,132 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Encompass.Exceptions;
-
-namespace Encompass
-{
-    internal class DrawLayerManager
-    {
-        private readonly SortedList<int, int> _layerOrder = new SortedList<int, int>();
-
-        private readonly Dictionary<int, Dictionary<Type, HashSet<int>>> _layerIndexToTypeToID = new Dictionary<int, Dictionary<Type, HashSet<int>>>();
-        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);
-        public IEnumerable<int> LayerOrder { get { return _layerOrder.Values; } }
-
-        public DrawLayerManager()
-        {
-            RegisterDrawLayer(0);
-        }
-
-        public void RegisterDrawLayer(int layer)
-        {
-            if (!_layerIndexToTypeToID.ContainsKey(layer))
-            {
-                _layerOrder.Add(layer, layer);
-                _layerIndexToGeneralRenderers.Add(layer, new HashSet<GeneralRenderer>());
-                _layerIndexToTypeToID.Add(layer, new Dictionary<Type, HashSet<int>>());
-            }
-        }
-
-        public void RegisterOrderedDrawable<TComponent>() where TComponent : struct
-        {
-            if (!_typeToEntityToLayer.ContainsKey(typeof(TComponent)))
-            {
-                _typeToEntityToLayer.Add(typeof(TComponent), new Dictionary<int, int>(128));
-            }
-
-            foreach (var pair in _layerIndexToTypeToID)
-            {
-                if (!pair.Value.ContainsKey(typeof(TComponent)))
-                {
-                    pair.Value.Add(typeof(TComponent), new HashSet<int>());
-                }
-            }
-        }
-
-        public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
-        {
-            RegisterDrawLayer(layer);
-            var set = _layerIndexToGeneralRenderers[layer];
-            set.Add(renderer);
-        }
-
-        public void RegisterComponentWithLayer<TComponent>(int entityID, int layer) where TComponent : struct
-        {
-            if (!_layerIndexToTypeToID.ContainsKey(layer))
-            {
-                throw new UndefinedLayerException("Layer {0} is not defined. Use WorldBuilder.RegisterDrawLayer to register the layer.", layer);
-            }
-
-            if (_typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID))
-            {
-                if (_typeToEntityToLayer[typeof(TComponent)][entityID] != layer)
-                {
-                    UnRegisterComponentWithLayer<TComponent>(entityID);
-
-                    var set = _layerIndexToTypeToID[layer][typeof(TComponent)];
-                    set.Add(entityID);
-
-                    _typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer);
-                }
-            }
-            else
-            {
-                var set = _layerIndexToTypeToID[layer][typeof(TComponent)];
-                set.Add(entityID);
-
-                _typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer);
-            }
-        }
-
-        public void UnRegisterComponentWithLayer<TComponent>(int entityID) where TComponent : struct
-        {
-            if (!_typeToEntityToLayer.ContainsKey(typeof(TComponent))) { return; }
-
-            if (_typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID))
-            {
-                var layer = _typeToEntityToLayer[typeof(TComponent)][entityID];
-                _layerIndexToTypeToID[layer][typeof(TComponent)].Remove(entityID);
-            }
-            _typeToEntityToLayer[typeof(TComponent)].Remove(entityID);
-        }
-
-        public void UnRegisterEntityWithLayer(int entityID)
-        {
-            foreach (var store in _layerIndexToTypeToID.Values)
-            {
-                foreach (var typeToSet in store)
-                {
-                    var type = typeToSet.Key;
-                    var set = typeToSet.Value;
-
-                    if (set.Contains(entityID))
-                    {
-                        _typeToEntityToLayer[type].Remove(entityID);
-                        set.Remove(entityID);
-                    }
-                }
-            }
-        }
-
-        public IEnumerable<GeneralRenderer> GeneralRenderersByLayer(int layer)
-        {
-            return _layerIndexToGeneralRenderers.ContainsKey(layer) ?
-                _layerIndexToGeneralRenderers[layer] :
-                Enumerable.Empty<GeneralRenderer>();
-        }
-
-        public IEnumerable<(int, Type)> AllInLayer(int layer)
-        {
-            foreach (var kvp in _layerIndexToTypeToID[layer])
-            {
-                foreach (var id in kvp.Value)
-                {
-                    yield return (id, kvp.Key);
-                }
-            }
-        }
-    }
-}

encompass-cs/Engine.cs

@@ -23,6 +23,7 @@ namespace Encompass
         internal readonly HashSet<Type> WriteImmediateTypes = new HashSet<Type>();
         internal readonly HashSet<Type> QueryWithTypes = new HashSet<Type>();
         internal readonly HashSet<Type> QueryWithoutTypes = new HashSet<Type>();
+        internal readonly HashSet<Type> AddTypes = new HashSet<Type>();
         internal readonly Dictionary<Type, int> WritePriorities = new Dictionary<Type, int>();
         internal readonly int DefaultWritePriority = 0;
 
@@ -58,6 +59,12 @@ namespace Encompass
         {
             _id = Guid.NewGuid();
 
+            var addsAttribute = GetType().GetCustomAttribute<Adds>(false);
+            if (addsAttribute != null)
+            {
+                AddTypes = addsAttribute.addTypes;
+            }
+
             var sendsAttribute = GetType().GetCustomAttribute<Sends>(false);
             if (sendsAttribute != null)
             {
@@ -169,7 +176,7 @@ namespace Encompass
             _trackingManager = trackingManager;
         }
 
-        internal void CheckMessageRead<TMessage>() where TMessage : struct, IMessage
+        internal void CheckMessageRead<TMessage>() where TMessage : struct
         {
             if (!ReceiveTypes.Contains(typeof(TMessage)))
             {
@@ -222,7 +229,7 @@ namespace Encompass
         /// <summary>
         /// Returns all Entities containing the specified Component type.
         /// </summary>
-        protected ReadOnlySpan<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
+        protected ReadOnlySpan<Entity> ReadEntities<TComponent>() where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -247,7 +254,7 @@ namespace Encompass
         /// <summary>
         /// Returns an Entity containing the specified Component type.
         /// </summary>
-        protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
+        protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -272,7 +279,7 @@ namespace Encompass
         /// <summary>
         /// Returns all of the Components with the specified Component Type.
         /// </summary>
-        protected ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
+        protected ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -297,7 +304,7 @@ namespace Encompass
         /// <summary>
         /// Returns a Component with the specified Component Type. If multiples exist, an arbitrary Component is returned.
         /// </summary>
-        protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct, IComponent
+        protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -322,7 +329,7 @@ namespace Encompass
         /// <summary>
         /// Returns true if any Component with the specified Component Type exists.
         /// </summary>
-        protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
+        protected bool SomeComponent<TComponent>() where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -344,7 +351,7 @@ namespace Encompass
             }
         }
 
-        private ref TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct, IComponent
+        private ref TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -375,7 +382,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalReadException">
         /// Thrown when the Engine does not declare that it reads the given Component Type.
         /// </exception>
-        protected ref readonly TComponent GetComponent<TComponent>(in Entity entity) where TComponent : struct, IComponent
+        protected ref readonly TComponent GetComponent<TComponent>(in Entity entity) where TComponent : struct
         {
             return ref GetComponentHelper<TComponent>(entity.ID);
         }
@@ -386,7 +393,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalReadException">
         /// Thrown when the Engine does not declare that is Reads the given Component Type.
         /// </exception>
-        protected bool HasComponent<TComponent>(in Entity entity) where TComponent : struct, IComponent
+        protected bool HasComponent<TComponent>(in Entity entity) where TComponent : struct
         {
             var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
             var existingRead = ReadTypes.Contains(typeof(TComponent));
@@ -444,7 +451,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalWriteException">
         /// Thrown when the Engine does not declare that it Writes the given Component Type.
         /// </exception>
-        protected void SetComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct, IComponent
+        protected void SetComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct
         {
             var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
 
@@ -471,11 +478,6 @@ namespace Encompass
             {
                 _trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
             }
-
-            if (written && component is IDrawableComponent drawableComponent)
-            {
-                _componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
-            }
         }
 
         /// <summary>
@@ -484,8 +486,13 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalWriteException">
         /// Thrown when the Engine does not declare that it Writes the given Component Type.
         /// </exception>
-        protected void AddComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct, IComponent
+        protected void AddComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct
         {
+            if (!AddTypes.Contains(typeof(TComponent)))
+            {
+                throw new IllegalWriteException("Engine {0} tried to add undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
+            }
+
             if (!EntityCreatedThisFrame(entity.ID))
             {
                 throw new IllegalWriteException("AddComponent used on Entity that was not created in this context. Use SetComponent instead.");
@@ -502,11 +509,6 @@ namespace Encompass
             }
 
             _trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
-
-            if (component is IDrawableComponent drawableComponent)
-            {
-                _componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
-            }
         }
 
         /// <summary>
@@ -515,7 +517,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalSendException">
         /// Thrown when the Engine does not declare that it Sends the Message Type.
         /// </exception>
-        protected void SendMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
+        protected void SendMessage<TMessage>(in TMessage message) where TMessage : struct
         {
             if (!SendTypes.Contains(typeof(TMessage)))
             {
@@ -529,7 +531,7 @@ namespace Encompass
         /// Sends a message after the specified number of seconds, respecting time dilation.
         /// </summary>
         /// <param name="time">The time in seconds that will elapse before the message is sent.</param>
-        protected void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        protected void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             _messageManager.AddMessage(message, time);
         }
@@ -538,7 +540,7 @@ namespace Encompass
         /// Sends a message after the specified number of seconds, ignoring time dilation.
         /// </summary>
         /// <param name="time">The time in seconds that will elapse before the message is sent.</param>
-        protected void SendMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        protected void SendMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             _messageManager.AddMessageIgnoringTimeDilation(message, time);
         }
@@ -549,7 +551,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalReadException">
         /// Thrown when the Engine does not declare that it Receives the specified Message Type.
         /// </exception>
-        protected ReadOnlySpan<TMessage> ReadMessages<TMessage>() where TMessage : struct, IMessage
+        protected ReadOnlySpan<TMessage> ReadMessages<TMessage>() where TMessage : struct
         {
             CheckMessageRead<TMessage>();
             return _messageManager.GetMessagesByType<TMessage>();
@@ -561,7 +563,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalReadException">
         /// Thrown when the Engine does not declare that it Receives the specified Message Type.
         /// </exception>
-        protected ref readonly TMessage ReadMessage<TMessage>() where TMessage : struct, IMessage
+        protected ref readonly TMessage ReadMessage<TMessage>() where TMessage : struct
         {
             CheckMessageRead<TMessage>();
             return ref _messageManager.First<TMessage>();
@@ -573,7 +575,7 @@ namespace Encompass
         /// <exception cref="Encompass.Exceptions.IllegalReadException">
         /// Thrown when the Engine does not declare that it Receives the specified Message Type.
         /// </exception>
-        protected bool SomeMessage<TMessage>() where TMessage : struct, IMessage
+        protected bool SomeMessage<TMessage>() where TMessage : struct
         {
             CheckMessageRead<TMessage>();
             return _messageManager.Any<TMessage>();
@@ -592,7 +594,7 @@ namespace Encompass
         /// Destroys an arbitrary Entity containing a Component of the specified Type.
         /// Entity destruction takes place after all the Engines have been processed by World Update.
         /// </summary>
-        protected void DestroyWith<TComponent>() where TComponent : struct, IComponent
+        protected void DestroyWith<TComponent>() where TComponent : struct
         {
             Destroy(ReadEntity<TComponent>());
         }
@@ -601,7 +603,7 @@ namespace Encompass
         /// Destroys all Entities containing a Component of the specified Type.
         /// Entity destruction takes place after all the Engines have been processed by World Update.
         /// </summary>
-        protected void DestroyAllWith<TComponent>() where TComponent : struct, IComponent
+        protected void DestroyAllWith<TComponent>() where TComponent : struct
         {
             foreach (var entity in ReadEntities<TComponent>())
             {
@@ -614,7 +616,7 @@ namespace Encompass
         /// Note that the Engine must Read the Component type that is being removed.
         /// If a Component with the specified type does not exist on the Entity, returns false and does not mutate the Entity.
         /// </summary>
-        protected void RemoveComponent<TComponent>(in Entity entity) where TComponent : struct, IComponent
+        protected void RemoveComponent<TComponent>(in Entity entity) where TComponent : struct
         {
             var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
 
@@ -707,7 +709,7 @@ namespace Encompass
         /// <typeparam name="TMessage">The Message subtype.</typeparam>
         /// <param name="entity">The entity that all messages in the IEnumerable refer to.</param>
         /// <returns></returns>
-        protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(in Entity entity) where TMessage : struct, IMessage, IHasEntity
+        protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(in Entity entity) where TMessage : struct, IHasEntity
         {
             CheckMessageRead<TMessage>();
             return _messageManager.WithEntity<TMessage>(entity.ID);
@@ -717,7 +719,7 @@ namespace Encompass
         /// Efficiently reads a single Message of a given type that references a given Entity.
         /// It is recommended to use this method in conjunction with SomeMessageWithEntity to prevent errors.
         /// </summary>
-        protected ref readonly TMessage ReadMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IMessage, IHasEntity
+        protected ref readonly TMessage ReadMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IHasEntity
         {
             CheckMessageRead<TMessage>();
             return ref _messageManager.WithEntitySingular<TMessage>(entity.ID);
@@ -726,7 +728,7 @@ namespace Encompass
         /// <summary>
         /// Efficiently checks if any Message of a given type referencing a given Entity exists.
         /// </summary>
-        protected bool SomeMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IMessage, IHasEntity
+        protected bool SomeMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IHasEntity
         {
             CheckMessageRead<TMessage>();
             return _messageManager.SomeWithEntity<TMessage>(entity.ID);

encompass-cs/Engines/Spawner.cs

@@ -6,7 +6,7 @@ namespace Encompass
     /// A Spawner is a special type of Engine that runs a Spawn method in response to each Message it receives.
     /// Spawners are useful for organizing the building of new Entities in your game.
     /// </summary>
-    public abstract class Spawner<TMessage> : Engine where TMessage : struct, IMessage
+    public abstract class Spawner<TMessage> : Engine where TMessage : struct
     {
         protected Spawner() : base()
         {

encompass-cs/Exceptions/IllegalSendTypeException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace Encompass.Exceptions
-{
-    public class IllegalSendTypeException : Exception
-    {
-        public IllegalSendTypeException(
-            string format,
-            params object[] args
-        ) : base(string.Format(format, args)) { }
-    }
-}

encompass-cs/IMessage.cs

@@ -1,7 +0,0 @@
-namespace Encompass
-{
-    /// <summary>
-    /// Structs that implement IMessage are considered to be Messages.
-    /// </summary>
-    public interface IMessage { }
-}

encompass-cs/Interfaces/IComponent.cs

@@ -1,4 +0,0 @@
-namespace Encompass
-{
-    public interface IComponent { }
-}

encompass-cs/Interfaces/IDrawableComponent.cs

@@ -1,7 +0,0 @@
-namespace Encompass
-{
-    public interface IDrawableComponent
-    {
-        int Layer { get; }
-    }
-}

encompass-cs/MessageManager.cs

@@ -13,17 +13,17 @@ namespace Encompass
             _timeManager = timeManager;
         }
 
-        internal void AddMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
+        internal void AddMessage<TMessage>(in TMessage message) where TMessage : struct
         {
             _messageStore.AddMessage(message);
         }
 
-        internal void AddMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        internal void AddMessage<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             _messageStore.AddMessage(message, time);
         }
 
-        internal void AddMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        internal void AddMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             _messageStore.AddMessageIgnoringTimeDilation(message, time);
         }
@@ -38,32 +38,32 @@ namespace Encompass
             _messageStore.ProcessDelayedMessages(dt * _timeManager.TimeDilationFactor, dt);
         }
 
-        internal ReadOnlySpan<TMessage> GetMessagesByType<TMessage>() where TMessage : struct, IMessage
+        internal ReadOnlySpan<TMessage> GetMessagesByType<TMessage>() where TMessage : struct
         {
             return _messageStore.All<TMessage>();
         }
 
-        internal bool Any<TMessage>() where TMessage : struct, IMessage
+        internal bool Any<TMessage>() where TMessage : struct
         {
             return _messageStore.Any<TMessage>();
         }
 
-        internal ref readonly TMessage First<TMessage>() where TMessage : struct, IMessage
+        internal ref readonly TMessage First<TMessage>() where TMessage : struct
         {
             return ref _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, IHasEntity
         {
             return _messageStore.WithEntity<TMessage>(entityID);
         }
 
-        internal ref readonly TMessage WithEntitySingular<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
+        internal ref readonly TMessage WithEntitySingular<TMessage>(int entityID) where TMessage : struct, IHasEntity
         {
             return ref _messageStore.FirstWithEntity<TMessage>(entityID);
         }
 
-        internal bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
+        internal bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IHasEntity
         {
             return _messageStore.SomeWithEntity<TMessage>(entityID);
         }

encompass-cs/RenderManager.cs

@@ -1,51 +1,27 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
 
 namespace Encompass
 {
     internal class RenderManager
     {
         private readonly EntityManager _entityManager;
-        private readonly DrawLayerManager _drawLayerManager;
+        private readonly List<Renderer> renderers = new List<Renderer>();
 
-        private readonly Dictionary<Type, Action<Entity>> _drawComponentTypeToOrderedRenderer = new Dictionary<Type, Action<Entity>>(256);
+        public RenderManager(EntityManager entityManager)
-
-        public RenderManager(EntityManager entityManager, DrawLayerManager drawLayerManager)
         {
             _entityManager = entityManager;
-            _drawLayerManager = drawLayerManager;
         }
 
-        public void RegisterOrderedRenderer<TComponent>(Action<Entity> renderAction) where TComponent : struct
+        public void AddRenderer(Renderer renderer)
         {
-            _drawComponentTypeToOrderedRenderer.Add(typeof(TComponent), renderAction);
+            renderers.Add(renderer);
-            _drawLayerManager.RegisterOrderedDrawable<TComponent>();
-        }
-
-        public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
-        {
-            _drawLayerManager.RegisterGeneralRendererWithLayer(renderer, layer);
         }
 
         public void Draw()
         {
-            foreach (var layer in _drawLayerManager.LayerOrder)
+            foreach (var renderer in renderers)
             {
-                var generalRendererSet = _drawLayerManager.GeneralRenderersByLayer(layer);
+                renderer.Render();
-
-                foreach (var (entityID, componentType) in _drawLayerManager.AllInLayer(layer))
-                {
-                    if (_drawComponentTypeToOrderedRenderer.ContainsKey(componentType))
-                    {
-                        var internalRenderAction = _drawComponentTypeToOrderedRenderer[componentType];
-                        internalRenderAction(_entityManager.GetEntity(entityID));
-                    }
-                }
-
-                foreach (var generalRenderer in generalRendererSet)
-                {
-                    generalRenderer.Render();
-                }
             }
         }
     }

encompass-cs/Renderer.cs

@@ -18,47 +18,49 @@ namespace Encompass
             _componentManager = componentManager;
         }
 
-        protected ReadOnlySpan<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
+        public abstract void Render();
+
+        protected ReadOnlySpan<Entity> ReadEntities<TComponent>() where TComponent : struct
         {
             return _componentManager.GetExistingEntities<TComponent>();
         }
 
-        protected IEnumerable<Entity> ReadEntitiesAsEnumerable<TComponent>() where TComponent : struct, IComponent
+        protected IEnumerable<Entity> ReadEntitiesAsEnumerable<TComponent>() where TComponent : struct
         {
             return _componentManager.GetExistingEntitiesAsEnumerable<TComponent>();
         }
 
-        protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
+        protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct
         {
             return ref _componentManager.ExistingSingularEntity<TComponent>();
         }
 
-        protected ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
+        protected ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : struct
         {
             return _componentManager.GetComponentsByType<TComponent>();
         }
 
-        protected IEnumerable<TComponent> ReadComponentsAsEnumerable<TComponent>() where TComponent : struct, IComponent
+        protected IEnumerable<TComponent> ReadComponentsAsEnumerable<TComponent>() where TComponent : struct
         {
             return _componentManager.GetComponentsByTypeEnumerable<TComponent>();
         }
 
-        protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct, IComponent
+        protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct
         {
             return ref _componentManager.ExistingSingular<TComponent>();
         }
 
-        protected ref readonly TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
+        protected ref readonly TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct
         {
             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
         {
             return _componentManager.EntityHasComponentOfType<TComponent>(entity.ID);
         }
 
-        protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
+        protected bool SomeComponent<TComponent>() where TComponent : struct
         {
             return _componentManager.SomeExistingComponent<TComponent>();
         }

encompass-cs/Renderers/GeneralRenderer.cs

@@ -1,11 +0,0 @@
-namespace Encompass
-{
-    /// <summary>
-    /// GeneralRenderer is a Renderer which generically reads the game state in order to draw elements to the screen.
-    /// GeneralRenderers have a layer specified when they are added to the World.
-    /// </summary>
-    public abstract class GeneralRenderer : Renderer
-    {
-        public abstract void Render();
-    }
-}

encompass-cs/Renderers/OrderedRenderer.cs

@@ -1,18 +0,0 @@
-using System;
-
-namespace Encompass
-{
-    /// <summary>
-    /// OrdereredRenderer provides a structure for the common pattern of wishing to draw a specific DrawComponent at a specific layer.
-    /// </summary>
-    public abstract class OrderedRenderer<TComponent> : Renderer where TComponent : struct, IComponent, IDrawableComponent
-    {
-        public abstract void Render(Entity entity, in TComponent drawComponent);
-
-        internal void InternalRender(Entity entity)
-        {
-            ref readonly var component = ref GetComponent<TComponent>(entity);
-            Render(entity, component);
-        }
-    }
-}

encompass-cs/UberEngine.cs

@@ -14,6 +14,7 @@ namespace Encompass
         {
             _componentTypes = componentTypes;
             _messageTypes = messageTypes;
+            AddTypes.UnionWith(componentTypes);
             ReadTypes.UnionWith(componentTypes);
             WriteTypes.UnionWith(componentTypes);
             SendTypes.UnionWith(messageTypes);
@@ -54,7 +55,7 @@ namespace Encompass
 
         // we can't reflect invoke on byref returns or Span returns right now... so we have non-return wrapper methods
 
-        protected void CallAllComponentMethods<TComponent>() where TComponent : struct, IComponent
+        protected void CallAllComponentMethods<TComponent>() where TComponent : struct
         {
             ReadComponent<TComponent>();
             ReadComponents<TComponent>();
@@ -69,7 +70,7 @@ namespace Encompass
             AddComponent<TComponent>(Entity, default);
         }
 
-        protected void CallAllMessageMethods<TMessage>() where TMessage : struct, IMessage
+        protected void CallAllMessageMethods<TMessage>() where TMessage : struct
         {
             SendMessageIgnoringTimeDilation<TMessage>(default, 0.1);
             SendMessage<TMessage>(default);
@@ -79,7 +80,7 @@ namespace Encompass
             SomeMessage<TMessage>();
         }
 
-        protected void CallAllEntityMessageMethods<TMessage>() where TMessage : struct, IMessage, IHasEntity
+        protected void CallAllEntityMessageMethods<TMessage>() where TMessage : struct, IHasEntity
         {
             ReadMessagesWithEntity<TMessage>(Entity);
             ReadMessageWithEntity<TMessage>(Entity);

encompass-cs/UberRenderer.cs

@@ -20,7 +20,7 @@ namespace Encompass
         }
 
         // can't reflect invoke on Span returns...
-        public void Render()
+        public override void Render()
         {
             foreach (var type in _componentTypes)
             {
@@ -28,7 +28,7 @@ namespace Encompass
             }
         }
 
-        protected void CallAllComponentMethods<TComponent>() where TComponent : struct, IComponent
+        protected void CallAllComponentMethods<TComponent>() where TComponent : struct
         {
             ReadEntity<TComponent>();
             ReadEntities<TComponent>();

encompass-cs/WorldBuilder.cs

@@ -26,7 +26,6 @@ namespace Encompass
         private readonly EntityManager _entityManager;
         private readonly MessageManager _messageManager;
         private readonly TimeManager _timeManager;
-        private readonly DrawLayerManager _drawLayerManager;
         private readonly RenderManager _renderManager;
         private readonly TrackingManager _trackingManager;
 
@@ -36,18 +35,15 @@ namespace Encompass
         private readonly HashSet<Type> _messageTypes = new HashSet<Type>();
         private readonly Dictionary<Type, int> _typeToIndex = new Dictionary<Type, int>();
 
-        private bool _rendererRegistered = false;
-
         public WorldBuilder(int entityCapacity = 32768)
         {
             _entityCapacity = entityCapacity;
-            _drawLayerManager = new DrawLayerManager();
             _timeManager = new TimeManager();
             _trackingManager = new TrackingManager();
-            _componentManager = new ComponentManager(_drawLayerManager, _typeToIndex);
+            _componentManager = new ComponentManager(_typeToIndex);
             _messageManager = new MessageManager(_timeManager);
             _entityManager = new EntityManager(_componentManager, entityCapacity);
-            _renderManager = new RenderManager(_entityManager, _drawLayerManager);
+            _renderManager = new RenderManager(_entityManager);
 
             _startingExistingComponentStore = new ComponentStore(_typeToIndex);
             _startingUpToDateComponentStore = new ComponentStore(_typeToIndex);
@@ -64,7 +60,7 @@ namespace Encompass
         /// <summary>
         /// Specifies that the given Message should be sent immediately on the first World Update.
         /// </summary>
-        public void SendMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
+        public void SendMessage<TMessage>(in TMessage message) where TMessage : struct
         {
             _messageManager.AddMessage(message);
         }
@@ -72,7 +68,7 @@ namespace Encompass
         /// <summary>
         /// Specifies that the given Message should be sent after the specified number of seconds after the first World Update.
         /// </summary>
-        public void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
+        public void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct
         {
             _messageManager.AddMessage<TMessage>(message, time);
         }
@@ -80,20 +76,21 @@ namespace Encompass
         /// <summary>
         /// Sets Component data for the specified Component Type on the specified Entity.
         /// </summary>
-        public void SetComponent<TComponent>(Entity entity, in TComponent component) where TComponent : struct, IComponent
+        public void SetComponent<TComponent>(Entity entity, in TComponent component) where TComponent : struct
         {
             RegisterComponentType<TComponent>();
             _startingExistingComponentStore.Set(entity.ID, component);
             _startingUpToDateComponentStore.Set(entity.ID, component);
+        }
 
-            if (component is IDrawableComponent drawableComponent)
+        internal void RegisterComponentTypeNonGeneric(Type type)
         {
-                _componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
+            var method = GetType().GetMethod("RegisterComponentType", BindingFlags.NonPublic | BindingFlags.Instance);
-                _drawLayerManager.RegisterOrderedDrawable<TComponent>();
+            var generic = method.MakeGenericMethod(type);
-            }
+            generic.Invoke(this, null);
         }
 
-        internal void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
+        internal void RegisterComponentType<TComponent>() where TComponent : struct
         {
             if (!_typeToIndex.ContainsKey(typeof(TComponent)))
             {
@@ -158,6 +155,26 @@ namespace Encompass
                 _senders.Add(engine);
             }
 
+            foreach (var componentType in engine.ReadTypes)
+            {
+                RegisterComponentTypeNonGeneric(componentType);
+            }
+
+            foreach (var componentType in engine.AddTypes)
+            {
+                RegisterComponentTypeNonGeneric(componentType);
+            }
+
+            foreach (var componentType in engine.WriteTypes)
+            {
+                RegisterComponentTypeNonGeneric(componentType);
+            }
+
+            foreach (var componentType in engine.WriteImmediateTypes)
+            {
+                RegisterComponentTypeNonGeneric(componentType);
+            }
+
             foreach (var componentType in engine.QueryWithTypes)
             {
                 _trackingManager.RegisterComponentTypeToEngine(componentType, engine);
@@ -200,44 +217,13 @@ namespace Encompass
         }
 
         /// <summary>
-        /// Registers a draw layer. This must be done before any Renderers are registered.
+        /// Adds the specified Renderer to the World.
         /// </summary>
-        /// <param name="layer">The draw layer to register.</param>
+        public void AddRenderer(Renderer renderer)
-        public void RegisterDrawLayer(int layer)
         {
-            if (_rendererRegistered)
-            {
-                throw new IllegalDrawLayerException("Cannot register a draw layer after a Renderer has been registered.");
-            }
-            _drawLayerManager.RegisterDrawLayer(layer);
-        }
-
-        /// <summary>
-        /// Adds the specified OrderedRenderer to the World.
-        /// </summary>
-        public OrderedRenderer<TComponent> AddOrderedRenderer<TComponent>(OrderedRenderer<TComponent> renderer) where TComponent : struct, IComponent, IDrawableComponent
-        {
-            RegisterComponentType<TComponent>();
-            renderer.AssignEntityManager(_entityManager);
             renderer.AssignComponentManager(_componentManager);
-            _renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender);
-            _rendererRegistered = true;
-            return renderer;
-        }
-
-        /// <summary>
-        /// Adds the specified GeneralRenderer to the World at the specified layer.
-        /// Higher layer numbers draw on top of lower layer numbers.
-        /// </summary>
-        /// <param name="renderer">An instance of a GeneralRenderer.</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
-        {
             renderer.AssignEntityManager(_entityManager);
-            renderer.AssignComponentManager(_componentManager);
+            _renderManager.AddRenderer(renderer);
-            _renderManager.RegisterGeneralRendererWithLayer(renderer, layer);
-            _rendererRegistered = true;
-            return renderer;
         }
 
         private void BuildEngineGraph()
@@ -441,44 +427,20 @@ namespace Encompass
         {
             var dummyTimeManager = new TimeManager();
             var dummyMessageManager = new MessageManager(dummyTimeManager);
-            var dummyDrawLayerManager = new DrawLayerManager();
             var dummyTrackingManager = new TrackingManager();
-            var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, _typeToIndex);
+            var dummyComponentManager = new ComponentManager(_typeToIndex);
             var dummyEntityManager = new EntityManager(dummyComponentManager, _entityCapacity);
-            var dummyRenderManager = new RenderManager(dummyEntityManager, dummyDrawLayerManager);
+            var dummyRenderManager = new RenderManager(dummyEntityManager);
 
-            // doing reflection to grab all component types, because not all writes need to be declared
+            var prepEngineOrder = new List<Engine>();
-            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
-            {
-                foreach (var componentType in assembly.GetTypes())
-                {
-                    if (typeof(IComponent).IsAssignableFrom(componentType) && componentType.IsValueType && !componentType.IsEnum && !componentType.IsPrimitive)
-                    {
-                        var method = typeof(WorldBuilder).GetMethod("RegisterComponentType", BindingFlags.NonPublic | BindingFlags.Instance);
-                        var generic = method.MakeGenericMethod(componentType);
-                        generic.Invoke(this, null);
 
+            foreach (var componentType in _componentTypesToPreload)
+            {
                 var dummyRegisterMethod = typeof(ComponentManager).GetMethod("RegisterComponentType", BindingFlags.Public | BindingFlags.Instance);
                 var dummyGeneric = dummyRegisterMethod.MakeGenericMethod(componentType);
                 dummyGeneric.Invoke(dummyComponentManager, null);
             }
 
-                    if (componentType.GetInterface("IDrawableComponent") != null)
-                    {
-                        // register draw layer using property value
-                        var instance = Activator.CreateInstance(componentType);
-                        var layerPropertyInfo = componentType.GetProperty("Layer");
-                        dummyDrawLayerManager.RegisterDrawLayer((int)layerPropertyInfo.GetValue(instance));
-
-                        var drawLayerManagerRegisterMethod = typeof(DrawLayerManager).GetMethod("RegisterOrderedDrawable");
-                        var drawLayerManagerRegisterGenericMethod = drawLayerManagerRegisterMethod.MakeGenericMethod(componentType);
-                        drawLayerManagerRegisterGenericMethod.Invoke(dummyDrawLayerManager, null);
-                    }
-                }
-            }
-
-            var prepEngineOrder = new List<Engine>();
-
             var uberEngine = new UberEngine(_componentTypesToPreload, messageTypes);
 
             uberEngine.AssignEntityManager(dummyEntityManager);

test/ComponentTest.cs

@@ -8,12 +8,12 @@ namespace Tests
 {
     public class ComponentTests
     {
-        struct MockComponent : IComponent
+        struct MockComponent
         {
             public int myInt;
         }
 
-        struct EntityMessage : IMessage
+        struct EntityMessage
         {
             public Entity entity;
         }
@@ -33,7 +33,7 @@ namespace Tests
             }
         }
 
-        struct AddComponentTestMessage : IMessage
+        struct AddComponentTestMessage
         {
             public Entity entity;
             public MockComponent mockComponent;
@@ -62,8 +62,6 @@ namespace Tests
 
             var entity = worldBuilder.CreateEntity();
 
-            const string MyString = "hello";
-
             MockComponent mockComponent;
             mockComponent.myInt = 3;
 
@@ -174,7 +172,7 @@ namespace Tests
             Assert.DoesNotThrow(() => world.Update(0.01));
         }
 
-        struct AddMockComponentMessage : IMessage
+        struct AddMockComponentMessage
         {
             public Entity entity;
             public MockComponent mockComponent;
@@ -271,7 +269,7 @@ namespace Tests
 
             Assert.AreEqual(mockComponent, gottenMockComponent);
         }
-        struct HasComponentTestMessage : IMessage
+        struct HasComponentTestMessage
         {
             public Entity entity;
         }
@@ -369,7 +367,7 @@ namespace Tests
             Assert.IsFalse(hasComponentRuntimeTypeResult);
         }
 
-        struct RemoveComponentTestMessage : IMessage
+        struct RemoveComponentTestMessage
         {
             public Entity entity;
         }
@@ -463,7 +461,7 @@ namespace Tests
             hasComponentResult.Should().BeFalse();
         }
 
-        struct CheckHasMockComponentMessage : IMessage
+        struct CheckHasMockComponentMessage
         {
             public Entity entity;
             public bool shouldHaveComponent;

test/EngineTest.cs

@@ -10,7 +10,7 @@ using Encompass.Exceptions;
 
 namespace Tests
 {
-    struct MockComponent : IComponent
+    struct MockComponent
     {
         public int myInt;
     }
@@ -271,7 +271,7 @@ namespace Tests
             Assert.That(ex.Message, Is.EqualTo("Engine UndeclaredUpdateComponentTestEngine tried to update undeclared Component MockComponent"));
         }
 
-        struct MockMessage : IMessage
+        struct MockMessage
         {
             public string myString;
         }
@@ -435,7 +435,7 @@ namespace Tests
             Assert.Throws<IllegalReadException>(() => world.Update(0.01f));
         }
 
-        struct EntityMessage : IMessage, IHasEntity
+        struct EntityMessage : IHasEntity
         {
             public EntityMessage(Entity entity, int myInt)
             {
@@ -650,7 +650,7 @@ namespace Tests
             world.Update(0.01f);
         }
 
-        struct DestroyerComponent : IComponent { }
+        struct DestroyerComponent { }
 
         [Reads(typeof(DestroyerComponent))]
         class DestroyerEngine : Engine
@@ -955,7 +955,7 @@ namespace Tests
             resultComponents.Should().BeEmpty();
         }
 
-        struct DestroyComponentMessage : IMessage { public Entity entity; }
+        struct DestroyComponentMessage { public Entity entity; }
 
         [Reads(typeof(MockComponent))]
         [Writes(typeof(MockComponent))]
@@ -1007,7 +1007,7 @@ namespace Tests
             Assert.Throws<NoComponentOfTypeException>(() => world.Update(0.01), "No component of type MockComponent exists");
         }
 
-        struct MockComponentB : IComponent
+        struct MockComponentB
         {
             private int value;
 
@@ -1324,6 +1324,7 @@ namespace Tests
             undilatedDeltaTime.Should().Be(0.5);
         }
 
+        [Adds(typeof(MockComponent))]
         class AddComponentWithoutPriorityEngine : Engine
         {
             public override void Update(double dt)
@@ -1380,6 +1381,7 @@ namespace Tests
             Assert.Throws<IllegalWriteException>(() => world.Update(0.01));
         }
 
+        [Adds(typeof(MockComponentB))]
         [WritesImmediate(typeof(MockComponentB))]
         class AddImmediateComponentEngine : Engine
         {
@@ -1450,9 +1452,9 @@ namespace Tests
 
         public class QueryTests
         {
-            struct MockComponentB : IComponent { }
+            struct MockComponentB { }
-            struct MockComponentC : IComponent { }
+            struct MockComponentC { }
-            struct MockComponentD : IComponent { }
+            struct MockComponentD { }
 
             [Writes(typeof(MockComponentB))]
             [QueryWith(typeof(MockComponent), typeof(MockComponentB))]
@@ -1902,7 +1904,7 @@ namespace Tests
                 _components.Should().NotBeEmpty();
             }
 
-            struct MockTimerComponent : IComponent
+            struct MockTimerComponent
             {
                 public double Timer { get; }
 

test/OrderedRendererTest.cs

@@ -1,109 +0,0 @@
-using System;
-
-using NUnit.Framework;
-using FluentAssertions;
-using Encompass;
-using System.Collections.Generic;
-
-namespace Tests
-{
-    public class OrderedRendererTest
-    {
-        struct AComponent : IComponent { }
-        struct BComponent : IComponent { }
-        struct CComponent : IComponent { }
-
-        struct TestDrawComponent : IComponent, IDrawableComponent
-        {
-            public int Layer { get; set; }
-        }
-
-        class TestRenderer : OrderedRenderer<TestDrawComponent>
-        {
-            public override void Render(Entity entity, in TestDrawComponent testDrawComponent) { }
-        }
-
-        static bool called = false;
-        class DeactivatedRenderer : TestRenderer
-        {
-            public override void Render(Entity entity, in TestDrawComponent testDrawComponent)
-            {
-                called = true;
-            }
-        }
-
-        static bool calledOnDraw = false;
-        static (TestDrawComponent, Entity) resultComponent;
-
-        class CalledRenderer : OrderedRenderer<TestDrawComponent>
-        {
-            public override void Render(Entity entity, in TestDrawComponent testDrawComponent)
-            {
-                resultComponent = (testDrawComponent, entity);
-                calledOnDraw = true;
-            }
-        }
-
-        [Test]
-        public void RenderMethodCalledOnWorldDraw()
-        {
-            var worldBuilder = new WorldBuilder();
-            worldBuilder.RegisterDrawLayer(2);
-
-            var renderer = worldBuilder.AddOrderedRenderer(new CalledRenderer());
-
-            AComponent aComponent;
-            CComponent cComponent;
-
-            var testDrawComponent = new TestDrawComponent { Layer = 2 };
-
-            var entity = worldBuilder.CreateEntity();
-            worldBuilder.SetComponent(entity, aComponent);
-            worldBuilder.SetComponent(entity, cComponent);
-            worldBuilder.SetComponent(entity, testDrawComponent);
-
-            var world = worldBuilder.Build();
-
-            world.Update(0.01f);
-            world.Draw();
-
-            Assert.IsTrue(calledOnDraw);
-            resultComponent.Should().BeEquivalentTo((testDrawComponent, entity));
-        }
-
-        [Reads(typeof(TestDrawComponent))]
-        class DestroyerEngine : Engine
-        {
-            public override void Update(double dt)
-            {
-                foreach (var entity in ReadEntities<TestDrawComponent>())
-                {
-                    Destroy(entity);
-                }
-            }
-        }
-        [Test]
-        public void RenderMethodNotCalledAfterDestroy()
-        {
-            calledOnDraw = false;
-
-            var worldBuilder = new WorldBuilder();
-            worldBuilder.RegisterDrawLayer(1);
-
-            worldBuilder.AddEngine(new DestroyerEngine());
-            var renderer = worldBuilder.AddOrderedRenderer(new CalledRenderer());
-
-            TestDrawComponent testDrawComponent = new TestDrawComponent { Layer = 1 };
-
-            var entity = worldBuilder.CreateEntity();
-            worldBuilder.SetComponent(entity, testDrawComponent);
-
-            var world = worldBuilder.Build();
-
-            world.Update(0.01);
-            world.Draw();
-
-            Assert.IsFalse(calledOnDraw);
-        }
-    }
-}

test/RendererTest.cs

@@ -5,13 +5,13 @@ namespace Tests
 {
     public static class GeneralRendererTest
     {
-        struct AComponent : IComponent { }
+        struct AComponent { }
 
         public class SingletonRead
         {
             static (AComponent, Entity) result;
 
-            class TestRenderer : GeneralRenderer
+            class TestRenderer : Renderer
             {
                 public override void Render()
                 {
@@ -24,7 +24,7 @@ namespace Tests
             public void SingletonComponent()
             {
                 var worldBuilder = new WorldBuilder();
-                worldBuilder.AddGeneralRenderer(new TestRenderer(), 1);
+                worldBuilder.AddRenderer(new TestRenderer());
 
                 AComponent aComponent;
 
@@ -46,7 +46,7 @@ namespace Tests
             public void MultipleComponents()
             {
                 var worldBuilder = new WorldBuilder();
-                worldBuilder.AddGeneralRenderer(new TestRenderer(), 1);
+                worldBuilder.AddRenderer(new TestRenderer());
 
                 AComponent aComponent;
                 AComponent aComponentTwo;

test/SpawnerTest.cs

@@ -5,8 +5,8 @@ namespace Tests
 {
     public class SpawnerTest
     {
-        struct TestComponent : IComponent { }
+        struct TestComponent { }
-        struct SpawnMessageA : IMessage { }
+        struct SpawnMessageA { }
 
         static Entity resultEntity;
 

test/WorldBuilderTest.cs

@@ -13,8 +13,8 @@ namespace Tests
     {
         public class EngineCycleSimple
         {
-            struct AMessage : IMessage { }
+            struct AMessage { }
-            struct BMessage : IMessage { }
+            struct BMessage { }
 
             [Receives(typeof(AMessage))]
             [Sends(typeof(BMessage))]
@@ -51,10 +51,10 @@ namespace Tests
 
         public class EngineCycleComplex
         {
-            struct AMessage : IMessage { }
+            struct AMessage { }
-            struct BMessage : IMessage { }
+            struct BMessage { }
-            struct CMessage : IMessage { }
+            struct CMessage { }
-            struct DMessage : IMessage { }
+            struct DMessage { }
 
             [Receives(typeof(AMessage))]
             [Sends(typeof(BMessage))]
@@ -142,12 +142,12 @@ namespace Tests
 
         public class MultipleEngineWriteWithPriority
         {
-            struct SetMessage : IMessage
+            struct SetMessage
             {
                 public Entity entity;
             }
 
-            struct AComponent : IComponent
+            struct AComponent
             {
                 public int myInt;
             }
@@ -211,12 +211,12 @@ namespace Tests
 
         public class DefaultWritePriority
         {
-            struct SetMessage : IMessage
+            struct SetMessage
             {
                 public Entity entity;
             }
 
-            struct AComponent : IComponent
+            struct AComponent
             {
                 public int myInt;
             }
@@ -298,7 +298,7 @@ namespace Tests
 
         public class EngineMessageSelfCycle
         {
-            struct AMessage : IMessage { }
+            struct AMessage { }
 
             [Receives(typeof(AMessage))]
             [Sends(typeof(AMessage))]
@@ -319,28 +319,6 @@ namespace Tests
             }
         }
 
-        public class IllegalWriteType
-        {
-            struct ANonMessage { }
-
-            [Sends(typeof(ANonMessage))]
-            class MyEngine : Engine
-            {
-                public override void Update(double dt)
-                {
-
-                }
-            }
-
-            [Test]
-            public void ThrowsError()
-            {
-                var worldBuilder = new WorldBuilder();
-
-                Assert.Throws<IllegalSendTypeException>(() => worldBuilder.AddEngine(new MyEngine()), "ANonMessage must be a Message or Component");
-            }
-        }
-
         public class PriorityConflict
         {
             [Writes(typeof(MockComponent), 2)]
@@ -407,13 +385,13 @@ namespace Tests
         {
             static List<Engine> order = new List<Engine>();
 
-            struct AComponent : IComponent { }
+            struct AComponent { }
-            struct BComponent : IComponent { }
+            struct BComponent { }
 
-            struct AMessage : IMessage { }
+            struct AMessage { }
-            struct BMessage : IMessage { }
+            struct BMessage { }
-            struct CMessage : IMessage { }
+            struct CMessage { }
-            struct DMessage : IMessage { }
+            struct DMessage { }
 
             [Sends(typeof(AMessage))]
             class AEngine : Engine
@@ -520,8 +498,8 @@ namespace Tests
         {
             static List<Engine> order = new List<Engine>();
 
-            struct AMessage : IMessage { }
+            struct AMessage { }
-            struct BMessage : IMessage { }
+            struct BMessage { }
 
             [Sends(typeof(AMessage), typeof(BMessage))]
             class AEngine : Engine
@@ -558,57 +536,5 @@ namespace Tests
                 Assert.That(order.IndexOf(engineA), Is.LessThan(order.IndexOf(engineB)));
             }
         }
-
-        public class DrawLayerRegister
-        {
-            struct AComponent : IComponent, IDrawableComponent
-            {
-                public int Layer { get; }
-            }
-
-            struct BComponent : IComponent, IDrawableComponent
-            {
-                public int Layer { get => 3; }
-            }
-
-            class ARenderer : OrderedRenderer<AComponent>
-            {
-                public override void Render(Entity entity, in AComponent drawComponent) { }
-            }
-
-            class BRenderer : OrderedRenderer<BComponent>
-            {
-                public override void Render(Entity entity, in BComponent drawComponent) { }
-            }
-
-            [Test]
-            public void DrawLayerRegisterAfterOrderedRendererRegisterThrows()
-            {
-                var worldBuilder = new WorldBuilder();
-
-                var rendererA = worldBuilder.AddOrderedRenderer(new ARenderer());
-
-                Assert.Throws<IllegalDrawLayerException>(() => worldBuilder.RegisterDrawLayer(1));
-            }
-
-            [Test]
-            public void DrawLayerRegisterBeforeOrderedRendererDoesNotThrow()
-            {
-                var worldBuilder = new WorldBuilder();
-
-                Assert.DoesNotThrow(() => worldBuilder.RegisterDrawLayer(1));
-                Assert.DoesNotThrow(() => worldBuilder.AddOrderedRenderer(new ARenderer()));
-            }
-
-            [Test]
-            public void DrawLayerWithProperty()
-            {
-                var worldBuilder = new WorldBuilder();
-
-                var rendererB = worldBuilder.AddOrderedRenderer(new BRenderer());
-
-                Assert.DoesNotThrow(() => worldBuilder.Build());
-            }
-        }
     }
 }

test/WorldTest.cs

@@ -1,81 +0,0 @@
-using NUnit.Framework;
-using FluentAssertions;
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using Encompass;
-
-namespace Tests
-{
-    public class WorldTest
-    {
-        struct TestComponent : IComponent { }
-        struct TestDrawComponent : IComponent, IDrawableComponent
-        {
-            public int Layer { get; set; }
-        }
-
-        static List<object> drawOrder = new List<object>();
-
-        class TestEntityRenderer : OrderedRenderer<TestDrawComponent>
-        {
-            public override void Render(Entity entity, in TestDrawComponent testDrawComponent)
-            {
-                drawOrder.Add(entity);
-            }
-        }
-
-        class TestGeneralRenderer : GeneralRenderer
-        {
-            public override void Render()
-            {
-                drawOrder.Add(this);
-            }
-        }
-
-        [Test]
-        public void DrawOrder()
-        {
-            var worldBuilder = new WorldBuilder();
-            worldBuilder.RegisterDrawLayer(1);
-            worldBuilder.RegisterDrawLayer(2);
-            worldBuilder.RegisterDrawLayer(3);
-            worldBuilder.RegisterDrawLayer(4);
-            worldBuilder.RegisterDrawLayer(7);
-
-            worldBuilder.AddOrderedRenderer(new TestEntityRenderer());
-            var testGeneralRenderer = worldBuilder.AddGeneralRenderer(new TestGeneralRenderer(), 7);
-
-            TestComponent testComponent;
-            TestDrawComponent drawComponentThree = new TestDrawComponent { Layer = 3 };
-            var drawComponentTwo = new TestDrawComponent { Layer = 2 };
-            var drawComponentOne = new TestDrawComponent { Layer = 1 };
-            var drawComponentFour = new TestDrawComponent { Layer = 4 };
-
-            var entity = worldBuilder.CreateEntity();
-            worldBuilder.SetComponent(entity, testComponent);
-            worldBuilder.SetComponent(entity, drawComponentThree);
-
-            var entityTwo = worldBuilder.CreateEntity();
-            worldBuilder.SetComponent(entityTwo, testComponent);
-            worldBuilder.SetComponent(entityTwo, drawComponentTwo);
-
-            var entityThree = worldBuilder.CreateEntity();
-            worldBuilder.SetComponent(entityThree, testComponent);
-            worldBuilder.SetComponent(entityThree, drawComponentThree);
-
-            var entityFour = worldBuilder.CreateEntity();
-            worldBuilder.SetComponent(entityFour, testComponent);
-            worldBuilder.SetComponent(entityFour, drawComponentFour);
-
-            var world = worldBuilder.Build();
-
-            world.Update(0.01f);
-            world.Draw();
-
-            drawOrder.Should().BeEquivalentTo(entityFour, entityTwo, entity, entityThree, testGeneralRenderer);
-        }
-    }
-}