implement a fast enough data component.

Author: wuke32767

Celeste.Mod.mm/Mod/Registry/DataComponentRegistry.cs

@@ -0,0 +1,112 @@
+using Celeste.Mod.Registry;
+using Monocle;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+#nullable enable
+
+namespace Celeste.Mod.Registry {
+    internal class DataComponentRegistrySlotHolder {
+        internal required int depth;
+        internal required int slot;
+        internal required List<RegistryInfo?> registered;
+    }
+
+    public class RegistryInfo {
+        [AllowNull] public string ModName;
+        [AllowNull] public string Description;
+    }
+
+    public static class DataComponentRegistry {
+        internal static int getHierarchyDepth(Type? self) {
+            int depth = 0;
+            while (self is not null) {
+                self = self.BaseType;
+                depth++;
+            }
+            return depth - 1;
+        }
+
+        internal static ref TRet? ReadSlot<T, TRet>(this DataComponentRegistrySlotHolder slotHolder, T self) where T : patch_Entity where TRet : class? {
+            self.slots ??= new object[getHierarchyDepth(self.GetType())][];
+            ref object[]? curDepth = ref self.slots[slotHolder.depth];
+            
+            if (curDepth is not { }) {
+                curDepth = new object[slotHolder.registered.Count];
+            } else if (curDepth.Length <= slotHolder.slot) {
+                Array.Resize(ref curDepth, slotHolder.registered.Count);
+            }
+            return ref Unsafe.As<object, TRet?>(ref curDepth[slotHolder.slot]);
+        }
+
+        public delegate ref TRet Accessor<T, TRet>(T self) where T : patch_Entity where TRet : class?;
+
+        static Dictionary<Type, List<RegistryInfo?>> infos = new();
+        /// <summary>
+        /// A performant data holder implementation.
+        /// Allows you to attach any data to a type of entity.
+        /// </summary>
+        /// <remarks>
+        /// note: register new field and then access it *may* invalidate all existing references.
+        /// this can secretly happens in hook chain.
+        /// be careful with this one.
+        /// </remarks>
+        /// <typeparam name="T">Target entity type.</typeparam>
+        /// <typeparam name="TRet">Attached data type.</typeparam>
+        /// <param name="info">
+        /// it's mainly for external tools, and not actually used anywhere.
+        /// type your modname and comment here.
+        /// </param>
+        /// <param name="debug">
+        /// if in debug mode, enable type check.
+        /// they should be not necessary, so you are allowed to disable them when publishing.
+        /// </param>
+        /// <returns>The field accessor. note that your field can be null if it's not initialized.</returns>
+        public static Accessor<T, TRet?> RegisterFor<T, TRet>(RegistryInfo? info, bool debug) where T : patch_Entity where TRet : class? {
+            if (!infos.TryGetValue(typeof(T), out List<RegistryInfo?>? list)) {
+                list = new();
+                infos.Add(typeof(T), list);
+            }
+
+            var slot = new DataComponentRegistrySlotHolder() { slot = list.Count, registered = list, depth = getHierarchyDepth(typeof(T)) - 1, };
+            list.Add(info);
+
+            Accessor<T, TRet?> reader = slot.ReadSlot<T, TRet>;
+
+            if (debug) {
+                Accessor<T, TRet?> _reader = reader;
+                reader = a => {
+                    ref TRet? got = ref _reader(a);
+                    if (got is { } && got.GetType() != typeof(TRet)) {
+                        throw new InvalidCastException();
+                    }
+                    return ref got;
+                };
+            }
+            return reader;
+        }
+        /// <summary>
+        /// A performant data holder implementation.
+        /// Allows you to attach any data to a type of entity.
+        /// </summary>
+        /// <remarks>
+        /// returns simple getter and setter.
+        /// </remarks>
+        /// <typeparam name="T">Target entity type.</typeparam>
+        /// <typeparam name="TRet">Attached data type.</typeparam>
+        /// <param name="info">
+        /// it's mainly for external tools, and not actually used anywhere.
+        /// type your modname and comment here.
+        /// </param>
+        /// <param name="debug">
+        /// if in debug mode, enable type check.
+        /// they should be not necessary, so you are allowed to disable them when publishing.
+        /// </param>
+        /// <returns>The field accessor. note that your field can be null if it's not initialized.</returns>
+        public static (Action<T, TRet?> setter, Func<T, TRet?> getter) RegisterForSimple<T, TRet>(RegistryInfo? info, bool debug) where T : patch_Entity where TRet : class? {
+            Accessor<T, TRet?> reader = RegisterFor<T, TRet>(info, debug);
+            return (((e, v) => reader(e) = v), e => reader(e));
+        }
+    }
+}

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

@@ -5,7 +5,9 @@
 using System.ComponentModel;
 
 namespace Monocle {
-    class patch_Entity : Entity {
+    public class patch_Entity : Entity {
+        internal object[][] slots = null;
+
         public new Scene Scene {
             [MonoModIgnore]
             get;