Add Entity Collider Components to Entities

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

@@ -0,0 +1,77 @@
+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
+        /// </summary>
+        public Type EntityType => typeof(T);
+
+        /// <summary>
+        /// The Action invoked on Collision, with the Entity 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 Added(Entity entity) {
+            base.Added(entity);
+            //Only called if Component is added post Scene Begin and Entity Adding and Awake time.
+            if (Scene != null) {
+                if (!Scene.Tracker.IsEntityTracked<T>()) {
+                    patch_Tracker.AddTypeToTracker(typeof(T));
+                }
+                (Scene.Tracker as patch_Tracker).Refresh();
+            }
+        }
+
+        public override void EntityAdded(Scene scene) {
+            if (!scene.Tracker.IsEntityTracked<T>()) {
+                patch_Tracker.AddTypeToTracker(typeof(T));
+            }
+            base.EntityAdded(scene);
+        }
+
+        public override void EntityAwake() {
+            (Scene.Tracker as patch_Tracker).Refresh();
+        }
+
+        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,78 @@
+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
+        /// </summary>
+        public 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 Added(Entity entity) {
+            base.Added(entity);
+            //Only called if Component is added post Scene Begin and Entity Adding and Awake time.
+            if (Scene != null) {
+                if (!Scene.Tracker.IsComponentTracked<T>()) {
+                    patch_Tracker.AddTypeToTracker(typeof(T));
+                }
+                (Scene.Tracker as patch_Tracker).Refresh();
+            }
+        }
+
+        public override void EntityAdded(Scene scene) {
+            if (!scene.Tracker.IsComponentTracked<T>()) {
+                patch_Tracker.AddTypeToTracker(typeof(T));
+            }
+            base.EntityAdded(scene);
+        }
+
+        public override void EntityAwake() {
+            (Scene.Tracker as patch_Tracker).Refresh();
+        }
+
+        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

@@ -39,6 +39,8 @@ class patch_Tracker : Tracker {
         private static Type[] _temporaryAllTypes;
 
         private static Type[] GetAllTypesUncached() => FakeAssembly.GetFakeEntryAssembly().GetTypesSafe();
+
+        private bool Unrefreshed;
 
         [MonoModReplace]
         private static List<Type> GetSubclasses(Type type) {
@@ -71,57 +73,93 @@ private static List<Type> GetSubclasses(Type type) {
                 object[] customAttributes = type.GetCustomAttributes(typeof(TrackedAsAttribute), inherit: false);
                 foreach (object customAttribute in customAttributes) {
                     TrackedAsAttribute trackedAs = customAttribute as TrackedAsAttribute;
-                    Type trackedAsType = trackedAs.TrackedAsType;
-                    bool inherited = trackedAs.Inherited;
-                    if (typeof(Entity).IsAssignableFrom(type)) {
-                        if (!type.IsAbstract) {
-                            // this is an entity. copy the registered types for the target entity
-                            if (!TrackedEntityTypes.ContainsKey(type)) {
-                                TrackedEntityTypes.Add(type, new List<Type>());
-                            }
-                            TrackedEntityTypes[type].AddRange(TrackedEntityTypes.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
-                            TrackedEntityTypes[type] = TrackedEntityTypes[type].Distinct().ToList();
-                        }
-                        if (inherited) {
-                            // do the same for subclasses
-                            foreach (Type subclass in GetSubclasses(type)) {
-                                if (!subclass.IsAbstract) {
-                                    if (!TrackedEntityTypes.ContainsKey(subclass))
-                                        TrackedEntityTypes.Add(subclass, new List<Type>());
-                                    TrackedEntityTypes[subclass].AddRange(TrackedEntityTypes.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
-                                    TrackedEntityTypes[subclass] = TrackedEntityTypes[subclass].Distinct().ToList();
-                                }
-                            }
-                        }
-                    } else if (typeof(Component).IsAssignableFrom(type)) {
-                        if (!type.IsAbstract) {
-                            // this is an component. copy the registered types for the target component
-                            if (!TrackedComponentTypes.ContainsKey(type)) {
-                                TrackedComponentTypes.Add(type, new List<Type>());
-                            }
-                            TrackedComponentTypes[type].AddRange(TrackedComponentTypes.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
-                            TrackedComponentTypes[type] = TrackedComponentTypes[type].Distinct().ToList();
-                        }
-                        if (inherited) {
-                            // do the same for subclasses
-                            foreach (Type subclass in GetSubclasses(type)) {
-                                if (!subclass.IsAbstract) {
-                                    if (!TrackedComponentTypes.ContainsKey(subclass))
-                                        TrackedComponentTypes.Add(subclass, new List<Type>());
-                                    TrackedComponentTypes[subclass].AddRange(TrackedComponentTypes.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
-                                    TrackedComponentTypes[subclass] = TrackedComponentTypes[subclass].Distinct().ToList();
-                                }
-                            }
-                        }
-                    } else {
-                        // this is neither an entity nor a component. Help!
-                        throw new Exception("Type '" + type.Name + "' cannot be TrackedAs because it does not derive from Entity or Component");
-                    }
+                    AddTypeToTracker(type, trackedAs.TrackedAsType, trackedAs.Inherited);
                 }
             }
+            (Engine.Scene.Tracker as patch_Tracker).Unrefreshed = false;
 
             // 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) {
+            (Engine.Scene.Tracker as patch_Tracker).Unrefreshed = true;
+            Type trackedAsType = trackedAs != null && trackedAs.IsAssignableFrom(type) ? trackedAs : type;
+            bool? trackedEntity = typeof(Entity).IsAssignableFrom(type) ? true : typeof(Component).IsAssignableFrom(type) ? false : null;
+            if (trackedEntity == null) {
+                // this is neither an entity nor a component. Help!
+                throw new Exception("Type '" + type.Name + "' cannot be Tracked" + (trackedAsType != type ? "As" : "") + " because it does not derive from Entity or Component");
+            }
+            // copy the registered types for the target type
+            ((bool)trackedEntity ? StoredEntityTypes : StoredComponentTypes).Add(type);
+            Dictionary<Type, List<Type>> tracked = (bool)trackedEntity ? TrackedEntityTypes : TrackedComponentTypes;
+            if (!type.IsAbstract) {
+                if (!tracked.TryGetValue(type, out List<Type> value)) {
+                    value = new List<Type>();
+                    tracked.Add(type, value);
+                }
+                value.AddRange(tracked.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
+                tracked[type] = value.Distinct().ToList();
+            }
+            // do the same for subclasses
+            foreach (Type subtype in subtypes) {
+                if (trackedAsType.IsAssignableFrom(subtype) && !subtype.IsAbstract) {
+                    if (!tracked.TryGetValue(subtype, out List<Type> value)) {
+                        value = new List<Type>();
+                        tracked.Add(subtype, value);
+                    }
+                    value.AddRange(tracked.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
+                    tracked[subtype] = value.Distinct().ToList();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Ensures the current scene's tracker contains all entities of all tracked Types.
+        /// Must be called if a type is added to the tracker manually and if the active scene changes.
+        /// If called back to back without a type added to the Tracker, it won't go through again, for performance.
+        /// <paramref name="force"/> will make ensure the Refresh happens, even if run back to back.
+        /// Due to only the active Scene's Tracker's refreshed state is changed, <paramref name="force"/> must be true if a different scene becomes active.
+        /// </summary>
+        public void Refresh(bool force = false) {
+            if (!Unrefreshed && !force) {
+                return;
+            }
+            Unrefreshed = false;
+            foreach (Type entityType in StoredEntityTypes) {
+                if (!Entities.ContainsKey(entityType)) {
+                    Entities.Add(entityType, new List<Entity>());
+                }
+            }
+            foreach (Type componentType in StoredComponentTypes) {
+                if (!Components.ContainsKey(componentType)) {
+                    Components.Add(componentType, new List<Component>());
+                }
+            }
+            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)
+                        || Components[componentType].Contains(component)) {
+                        continue;
+                    }
+                    foreach (Type trackedType in componentTypes) {
+                        Components[trackedType].Add(component);
+                    }
+                }
+                Type entityType = entity.GetType();
+                if (!TrackedEntityTypes.TryGetValue(entityType, out List<Type> entityTypes)
+                    || Entities[entityType].Contains(entity)) {
+                    continue;
+                }
+                foreach (Type trackedType in entityTypes) {
+                    Entities[trackedType].Add(entity);
+                }
+            }
+        }
     }
 }