Add Entity Collider Components to Entities

Celeste.Mod.mm/Mod/Entities/EntityCollider.cs

@@ -0,0 +1,62 @@
+using Monocle;
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Celeste.Mod.Entities {
+    /// <summary>
+    /// Allows for Collision with any type of entity in the game, similar to a PlayerCollider or PufferCollider.
+    /// Performs the Action provided on collision. 
+    /// </summary>
+    /// <typeparam name="T">The specific type of Entity this component should try to collide with</typeparam>
+    [Tracked(false)]
+    public class EntityCollider<T> : Component where T : Entity {
+        /// <summary>
+        /// Provides a simple way to know the Entity type of the specific Collider without Reflection
+        /// </summary>
+        public readonly Type entityType = typeof(T);
+
+        /// <summary>
+        /// The Action invoked on Collision, with the Component collided with passed as a parameter
+        /// </summary>
+        public Action<T> OnEntityAction;
+
+        public Collider Collider;
+
+        public EntityCollider(Action<T> onEntityAction, Collider collider = null)
+            : base(active: true, visible: true) {
+            OnEntityAction = onEntityAction;
+            Collider = collider;
+        }
+
+        public override void EntityAdded(Scene scene) {
+            if (!scene.Tracker.IsEntityTracked<T>()) {
+                patch_Tracker.AddTypeToTracker(typeof(T));
+            }
+            base.EntityAdded(scene);
+        }
+
+        public override void Update() {
+            if (OnEntityAction == null) {
+                return;
+            }
+
+            Collider collider = Entity.Collider;
+            if (Collider != null) {
+                Entity.Collider = Collider;
+            }
+
+            Entity.CollideDo(OnEntityAction);
+
+            Entity.Collider = collider;
+        }
+
+        public override void DebugRender(Camera camera) {
+            if (Collider != null) {
+                Collider collider = Entity.Collider;
+                Entity.Collider = Collider;
+                Collider.Render(camera, Color.HotPink);
+                Entity.Collider = collider;
+            }
+        }
+    }
+}

Celeste.Mod.mm/Mod/Entities/EntityColliderByComponent.cs

@@ -0,0 +1,63 @@
+using Monocle;
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Celeste.Mod.Entities {
+    /// <summary>
+    /// Allows for Collision with any type of entity in the game, similar to a PlayerCollider or PufferCollider.
+    /// Collision is done by component, as in, it will get all the components of the type and try to collide with their entities.
+    /// Performs the Action provided on collision. 
+    /// </summary>
+    /// <typeparam name="T">The specific type of Component this component should try to collide with</typeparam>
+    [Tracked(false)]
+    public class EntityColliderByComponent<T> : Component where T : Component {
+        /// <summary>
+        /// Provides a simple way to know the Component type of the specific Collider without Reflection
+        /// </summary>
+        public readonly Type componentType = typeof(T);
+
+        /// <summary>
+        /// The Action invoked on Collision, with the Component collided with passed as a parameter
+        /// </summary>
+        public Action<T> OnComponentAction;
+
+        public Collider Collider;
+
+        public EntityColliderByComponent(Action<T> onComponentAction, Collider collider = null)
+            : base(active: true, visible: true) {
+            OnComponentAction = onComponentAction;
+            Collider = collider;
+        }
+
+        public override void EntityAdded(Scene scene) {
+            if (!scene.Tracker.IsComponentTracked<T>()) {
+                patch_Tracker.AddTypeToTracker(typeof(T));
+            }
+            base.EntityAdded(scene);
+        }
+
+        public override void Update() {
+            if (OnComponentAction == null) {
+                return;
+            }
+
+            Collider collider = Entity.Collider;
+            if (Collider != null) {
+                Entity.Collider = Collider;
+            }
+
+            Entity.CollideDoByComponent(OnComponentAction);
+
+            Entity.Collider = collider;
+        }
+
+        public override void DebugRender(Camera camera) {
+            if (Collider != null) {
+                Collider collider = Entity.Collider;
+                Entity.Collider = Collider;
+                Collider.Render(camera, Color.HotPink);
+                Entity.Collider = collider;
+            }
+        }
+    }
+}

Celeste.Mod.mm/Patches/Monocle/Tracker.cs

@@ -123,5 +123,109 @@ private static List<Type> GetSubclasses(Type type) {
             // don't hold references to all the types anymore
             _temporaryAllTypes = null;
         }
+
+        public static void AddTypeToTracker(Type type, Type trackedAs = null, bool inheritAll = false) {
+            AddTypeToTracker(type, trackedAs, inheritAll ? GetSubclasses(type).ToArray() : Array.Empty<Type>());
+        }
+
+        public static void AddTypeToTracker(Type type, Type trackedAs = null, params Type[] subtypes) {
+            if (typeof(Entity).IsAssignableFrom(type)) {
+                StoredEntityTypes.Add(type);
+                if (!type.IsAbstract) {
+                    if (!TrackedEntityTypes.TryGetValue(type, out List<Type> value)) {
+                        value = new List<Type>();
+                        TrackedEntityTypes.Add(type, value);
+                    }
+                    value.AddRange(TrackedEntityTypes.TryGetValue(trackedAs != null && trackedAs.IsAssignableFrom(type)
+                        ? trackedAs : type, out List<Type> list) ? list : new List<Type>());
+                    TrackedEntityTypes[type] = value.Distinct().ToList();
+                }
+                foreach (Type subtype in subtypes) {
+                    if (!subtype.IsAbstract) {
+                        if (!TrackedEntityTypes.TryGetValue(subtype, out List<Type> value)) {
+                            value = new List<Type>();
+                            TrackedEntityTypes.Add(subtype, value);
+                        }
+                        value.AddRange(TrackedEntityTypes.TryGetValue(trackedAs != null && trackedAs.IsAssignableFrom(type)
+                            ? trackedAs : type, out List<Type> list) ? list : new List<Type>());
+                        TrackedEntityTypes[subtype] = value.Distinct().ToList();
+                    }
+                }
+            }
+            else if (typeof(Component).IsAssignableFrom(type)) {
+                StoredComponentTypes.Add(type);
+                if (!type.IsAbstract) {
+                    if (!TrackedComponentTypes.TryGetValue(type, out List<Type> value)) {
+                        value = new List<Type>();
+                        TrackedComponentTypes.Add(type, value);
+                    }
+                    value.AddRange(TrackedComponentTypes.TryGetValue(trackedAs != null && trackedAs.IsAssignableFrom(type)
+                        ? trackedAs : type, out List<Type> list) ? list : new List<Type>());
+                    TrackedComponentTypes[type] = value.Distinct().ToList();
+                }
+                foreach(Type subtype in subtypes) {
+                    if (!subtype.IsAbstract) {
+                        if (!TrackedComponentTypes.TryGetValue(subtype, out List<Type> value)) {
+                            value = new List<Type>();
+                            TrackedComponentTypes.Add(subtype, value);
+                        }
+                        value.AddRange(TrackedComponentTypes.TryGetValue(trackedAs != null && trackedAs.IsAssignableFrom(type)
+                            ? trackedAs : type, out List<Type> list) ? list : new List<Type>());
+                        TrackedComponentTypes[subtype] = value.Distinct().ToList();
+                    }
+                }
+            }
+            else {
+                throw new Exception("Type '" + type.Name + "' cannot be TrackedAs because it does not derive from Entity or Component");
+            }
+            RefreshTracker(type);
+        }
+
+        public static void RefreshTracker(Type type) {
+            if (typeof(Entity).IsAssignableFrom(type) && !Engine.Scene.Tracker.Entities.ContainsKey(type)) {
+                Engine.Scene.Tracker.Entities.Add(type, new List<Entity>());
+            }
+            else if (typeof(Component).IsAssignableFrom(type) && !Engine.Scene.Tracker.Components.ContainsKey(type)) {
+                Engine.Scene.Tracker.Components.Add(type, new List<Component>());
+            } else {
+                throw new Exception("Type '" + type.Name + "' cannot be TrackedAs because it does not derive from Entity or Component");
+            }
+            RefreshTrackerLists();
+        }
+
+        public static void RefreshTracker() {
+            foreach (Type entityType in StoredEntityTypes) {
+                if (!Engine.Scene.Tracker.Entities.ContainsKey(entityType)) {
+                    Engine.Scene.Tracker.Entities.Add(entityType, new List<Entity>());
+                }
+            }
+            foreach (Type componentType in StoredComponentTypes) {
+                if (!Engine.Scene.Tracker.Components.ContainsKey(componentType)) {
+                    Engine.Scene.Tracker.Components.Add(componentType, new List<Component>());
+                }
+            }
+            RefreshTrackerLists();
+        }
+
+        private static void RefreshTrackerLists() {
+            foreach (Entity entity in Engine.Scene.Entities) {
+                foreach (Component component in entity.Components) {
+                    Type componentType = component.GetType();
+                    if (!TrackedComponentTypes.TryGetValue(componentType, out List<Type> componentTypes)) {
+                        continue;
+                    }
+                    foreach (Type trackedType in componentTypes) {
+                        Engine.Scene.Tracker.Components[trackedType].Add(component);
+                    }
+                }
+                Type entityType = entity.GetType();
+                if (!TrackedEntityTypes.TryGetValue(entityType, out List<Type> entityTypes)) {
+                    continue;
+                }
+                foreach (Type trackedType in entityTypes) {
+                    Engine.Scene.Tracker.Entities[trackedType].Add(entity);
+                }
+            }
+        }
     }
 }