adds ability to retrieve messages by entity

encompass-cs/Collections/MessageStore.cs

@@ -48,6 +48,11 @@ namespace Encompass
             return Lookup<TMessage>().Any();
         }
 
+        public IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
+        {
+            return Lookup<TMessage>().WithEntity(entityID);
+        }
+
         public void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta)
         {
             foreach (var store in Stores.Values)

encompass-cs/Collections/TypedMessageStore.cs

@@ -13,6 +13,7 @@ namespace Encompass
         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)> delayedStoreIgnoringTimeDilation = new List<(TMessage, double)>(128);
+        private readonly Dictionary<int, List<TMessage>> entityToMessage = new Dictionary<int, List<TMessage>>();
 
         public override void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta)
         {
@@ -54,6 +55,12 @@ namespace Encompass
         public void Add(TMessage message)
         {
             store.Add(message);
+            if (message is IHasEntity entityMessage)
+            {
+                var entityID = entityMessage.Entity.ID;
+                if (!entityToMessage.ContainsKey(entityID)) { entityToMessage.Add(entityID, new List<TMessage>()); }
+                entityToMessage[entityID].Add(message);
+            }
         }
 
         public void Add(TMessage message, double time)
@@ -81,9 +88,18 @@ namespace Encompass
             return store;
         }
 
+        public IEnumerable<TMessage> WithEntity(int entityID)
+        {
+            return entityToMessage[entityID];
+        }
+
         public override void Clear()
         {
             store.Clear();
+            foreach (var set in entityToMessage.Values)
+            {
+                set.Clear();
+            }
         }
     }
 }

encompass-cs/Engine.cs

@@ -647,6 +647,11 @@ namespace Encompass
             timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction);
         }
 
+        protected IEnumerable<TMessage> MessagesWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
+        {
+            return messageManager.WithEntity<TMessage>(entity.ID);
+        }
+
         internal void CheckAndUpdateTracking(int entityID)
         {
             if (_trackedEntities.Contains(entityID) && !entityQuery.CheckEntity(entityID, componentManager.ExistingBits))

encompass-cs/Interfaces/IHasEntity.cs

@@ -0,0 +1,7 @@
+namespace Encompass
+{
+    public interface IHasEntity
+    {
+        Entity Entity { get; }
+    }
+}

encompass-cs/MessageManager.cs

@@ -14,7 +14,7 @@ namespace Encompass
 
         internal void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
         {
-            messageStore.AddMessage<TMessage>(message);
+            messageStore.AddMessage(message);
         }
 
         internal void AddMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
@@ -51,5 +51,10 @@ namespace Encompass
         {
             return messageStore.First<TMessage>();
         }
+
+        internal IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
+        {
+            return messageStore.WithEntity<TMessage>(entityID);
+        }
     }
 }

test/EngineTest.cs

@@ -415,6 +415,74 @@ namespace Tests
             Assert.Throws<IllegalReadException>(() => world.Update(0.01f));
         }
 
+        struct EntityMessage : IMessage, IHasEntity 
+        { 
+            public EntityMessage(Entity entity, int myInt)
+            {
+                Entity = entity;
+                MyInt = myInt;
+            }
+
+            public Entity Entity { get; }
+            public int MyInt { get; }
+        }
+
+        [Sends(typeof(EntityMessage), typeof(MockMessage))]
+        class EntityMessageEmitterEngine : Engine
+        {
+            private Entity _entity;
+
+            public EntityMessageEmitterEngine(Entity entity)
+            {
+                _entity = entity;
+            }
+
+            public override void Update(double dt)
+            {
+                SendMessage(new EntityMessage(_entity, 2));
+                SendMessage(new EntityMessage(_entity, 4));
+                SendMessage(new EntityMessage(_entity, 5));
+                SendMessage(new MockMessage());
+            }
+        }
+
+        static List<EntityMessage> entityMessageResults;
+
+        [Receives(typeof(EntityMessage))]
+        class EntityMessageReceiverEngine : Engine
+        {
+            private Entity _entity;
+
+            public EntityMessageReceiverEngine(Entity entity)
+            {
+                _entity = entity;
+            }
+
+            public override void Update(double dt)
+            {
+                entityMessageResults = MessagesWithEntity<EntityMessage>(_entity).ToList();
+            }
+        }
+
+        [Test]
+        public void MessagesWithEntity()
+        {
+            var worldBuilder = new WorldBuilder();
+
+            var entity = worldBuilder.CreateEntity();
+            worldBuilder.AddEngine(new EntityMessageEmitterEngine(entity));
+            worldBuilder.AddEngine(new EntityMessageReceiverEngine(entity));
+
+            var world = worldBuilder.Build();
+
+            world.Update(0.01);
+
+            entityMessageResults.Should().HaveCount(3);
+            entityMessageResults.Should().ContainEquivalentOf(new EntityMessage(entity, 2));
+            entityMessageResults.Should().ContainEquivalentOf(new EntityMessage(entity, 4));
+            entityMessageResults.Should().ContainEquivalentOf(new EntityMessage(entity, 5));
+        }
+
         class SomeComponentTestEngine : Engine
         {
             public override void Update(double dt)