Add Entity Collider Components to Entities

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

@@ -0,0 +1,71 @@
+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>
+    public class EntityCollider<T> : Component where T : Entity {
+        /// <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));
+                }
+                patch_Tracker.Refresh(Scene);
+            }
+        }
+
+        public override void EntityAdded(Scene scene) {
+            if (!scene.Tracker.IsEntityTracked<T>()) {
+                patch_Tracker.AddTypeToTracker(typeof(T));
+            }
+            base.EntityAdded(scene);
+        }
+
+        public override void EntityAwake() {
+            patch_Tracker.Refresh(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,72 @@
+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>
+    public class EntityColliderByComponent<T> : Component where T : Component {
+        /// <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));
+                }
+                patch_Tracker.Refresh(Scene);
+            }
+        }
+
+        public override void EntityAdded(Scene scene) {
+            if (!scene.Tracker.IsComponentTracked<T>()) {
+                patch_Tracker.AddTypeToTracker(typeof(T));
+            }
+            base.EntityAdded(scene);
+        }
+
+        public override void EntityAwake() {
+            patch_Tracker.Refresh(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

@@ -39,15 +39,26 @@ class patch_Tracker : Tracker {
         private static Type[] _temporaryAllTypes;
 
         private static Type[] GetAllTypesUncached() => FakeAssembly.GetFakeEntryAssembly().GetTypesSafe();
-
+
+        private static int TrackedTypeVersion;
+
+        private int currentVersion;
+
+        public extern void orig_ctor();
+
+        [MonoModConstructor]
+        public void ctor() {
+            orig_ctor();
+            currentVersion = TrackedTypeVersion;
+        }
+
         [MonoModReplace]
         private static List<Type> GetSubclasses(Type type) {
             bool shouldNullOutCache = _temporaryAllTypes is null;
             _temporaryAllTypes ??= GetAllTypesUncached();
-            
+
             List<Type> subclasses = new();
-            foreach (Type otherType in _temporaryAllTypes)
-            {
+            foreach (Type otherType in _temporaryAllTypes) {
                 if (type != otherType && type.IsAssignableFrom(otherType))
                     subclasses.Add(otherType);
             }
@@ -56,72 +67,117 @@ private static List<Type> GetSubclasses(Type type) {
             // Let's do that now instead.
             if (shouldNullOutCache)
                 _temporaryAllTypes = null;
-            
+
             return subclasses;
         }
 
         public static extern void orig_Initialize();
         public new static void Initialize() {
             _temporaryAllTypes = GetAllTypesUncached();
-            
+
             orig_Initialize();
 
             // search for entities with [TrackedAs]
+            int oldVersion = TrackedTypeVersion;
             foreach (Type type in _temporaryAllTypes) {
                 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);
                 }
             }
-
+            TrackedTypeVersion = oldVersion;
             // 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) {
+            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");
+            }
+            bool updated = false;
+            // 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);
+                }
+                int cnt = value.Count;
+                value.AddRange(tracked.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
+                List<Type> result = tracked[type] = value.Distinct().ToList();
+                updated = cnt != result.Count;
+            }
+            // 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);
+                    }
+                    int cnt = value.Count;
+                    value.AddRange(tracked.TryGetValue(trackedAsType, out List<Type> list) ? list : new List<Type>());
+                    List<Type> result = tracked[subtype] = value.Distinct().ToList();
+                    updated = cnt != result.Count;
+                }
+            }
+            if (updated) {
+                TrackedTypeVersion++;
+            }
+        }
+
+        /// <summary>
+        /// Ensures the <paramref name="toUpdate"/>'s tracker contains all entities of all tracked Types from the <paramref name="toUpdate"/>.
+        /// Must be called if a type is added to the tracker manually and if the <paramref name="toUpdate"/>'s Tracker isn't refreshed.
+        /// 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.
+        /// Only the <paramref name="toUpdate"/>'s Tracker's refreshed state is changed.
+        /// If <paramref name="toUpdate"/> is null, it will default to Engine.Scene.
+        /// </summary>
+        public static void Refresh(Scene toUpdate = null, bool force = false) {
+            Scene scene = toUpdate ?? Engine.Scene;
+            if ((scene.Tracker as patch_Tracker).currentVersion >= TrackedTypeVersion && !force) {
+                return;
+            }
+            (scene.Tracker as patch_Tracker).currentVersion = TrackedTypeVersion;
+            foreach (Type entityType in StoredEntityTypes) {
+                if (!scene.Tracker.Entities.ContainsKey(entityType)) {
+                    scene.Tracker.Entities.Add(entityType, new List<Entity>());
+                }
+            }
+            foreach (Type componentType in StoredComponentTypes) {
+                if (!scene.Tracker.Components.ContainsKey(componentType)) {
+                    scene.Tracker.Components.Add(componentType, new List<Component>());
+                }
+            }
+            foreach (Entity entity in scene.Entities) {
+                foreach (Component component in entity.Components) {
+                    Type componentType = component.GetType();
+                    if (!TrackedComponentTypes.TryGetValue(componentType, out List<Type> componentTypes)
+                        || scene.Tracker.Components[componentType].Contains(component)) {
+                        continue;
+                    }
+                    foreach (Type trackedType in componentTypes) {
+                        scene.Tracker.Components[trackedType].Add(component);
+                    }
+                }
+                Type entityType = entity.GetType();
+                if (!TrackedEntityTypes.TryGetValue(entityType, out List<Type> entityTypes)
+                    || scene.Tracker.Entities[entityType].Contains(entity)) {
+                    continue;
+                }
+                foreach (Type trackedType in entityTypes) {
+                    scene.Tracker.Entities[trackedType].Add(entity);
+                }
+            }
+        }
     }
 }