From aaaff1fabacc2b85d32c7850b68f20f0ee770ffc Mon Sep 17 00:00:00 2001
From: Nytra <14206961+Nytra@users.noreply.github.com>
Date: Fri, 6 Sep 2024 12:35:43 +0100
Subject: [PATCH] Initial commit

---
 ...Loader.ModTemplate.sln => ArrayEditing.sln |   8 +-
 ArrayEditing/ArrayEditing.cs                  | 460 ++++++++++++++++++
 .../ArrayEditing.csproj                       |  43 +-
 .../Locale/de.json                            |   0
 .../Locale/en.json                            |   0
 .../Locale/jp.json                            |   0
 Directory.Build.props                         |   1 +
 .../BasicPrePatcher.cs                        |  42 --
 ...MonkeyLoader.ModTemplate.PrePatcher.csproj |  27 -
 .../MyConfig.cs                               |  29 --
 MonkeyLoader.ModTemplate/BasicPatcher.cs      |  29 --
 11 files changed, 475 insertions(+), 164 deletions(-)
 rename MonkeyLoader.ModTemplate.sln => ArrayEditing.sln (62%)
 create mode 100644 ArrayEditing/ArrayEditing.cs
 rename MonkeyLoader.ModTemplate/MonkeyLoader.ModTemplate.csproj => ArrayEditing/ArrayEditing.csproj (57%)
 rename {MonkeyLoader.ModTemplate => ArrayEditing}/Locale/de.json (100%)
 rename {MonkeyLoader.ModTemplate => ArrayEditing}/Locale/en.json (100%)
 rename {MonkeyLoader.ModTemplate => ArrayEditing}/Locale/jp.json (100%)
 delete mode 100644 MonkeyLoader.ModTemplate.PrePatcher/BasicPrePatcher.cs
 delete mode 100644 MonkeyLoader.ModTemplate.PrePatcher/MonkeyLoader.ModTemplate.PrePatcher.csproj
 delete mode 100644 MonkeyLoader.ModTemplate.PrePatcher/MyConfig.cs
 delete mode 100644 MonkeyLoader.ModTemplate/BasicPatcher.cs

diff --git a/MonkeyLoader.ModTemplate.sln b/ArrayEditing.sln
similarity index 62%
rename from MonkeyLoader.ModTemplate.sln
rename to ArrayEditing.sln
index c426db3..5e0f3b9 100644
--- a/MonkeyLoader.ModTemplate.sln
+++ b/ArrayEditing.sln
@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.5.33516.290
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MonkeyLoader.ModTemplate", "MonkeyLoader.ModTemplate\MonkeyLoader.ModTemplate.csproj", "{40835522-1978-431B-A395-0870583B80F5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ArrayEditing", "ArrayEditing\ArrayEditing.csproj", "{40835522-1978-431B-A395-0870583B80F5}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{07124CF9-EE3D-4A7E-A2F8-8FD07966E423}"
 	ProjectSection(SolutionItems) = preProject
@@ -11,8 +11,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		README.md = README.md
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MonkeyLoader.ModTemplate.PrePatcher", "MonkeyLoader.ModTemplate.PrePatcher\MonkeyLoader.ModTemplate.PrePatcher.csproj", "{F500B1A2-B913-4D93-941D-9BB5ABBDC800}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -23,10 +21,6 @@ Global
 		{40835522-1978-431B-A395-0870583B80F5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{40835522-1978-431B-A395-0870583B80F5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{40835522-1978-431B-A395-0870583B80F5}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F500B1A2-B913-4D93-941D-9BB5ABBDC800}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F500B1A2-B913-4D93-941D-9BB5ABBDC800}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F500B1A2-B913-4D93-941D-9BB5ABBDC800}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F500B1A2-B913-4D93-941D-9BB5ABBDC800}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/ArrayEditing/ArrayEditing.cs b/ArrayEditing/ArrayEditing.cs
new file mode 100644
index 0000000..9053599
--- /dev/null
+++ b/ArrayEditing/ArrayEditing.cs
@@ -0,0 +1,460 @@
+using Elements.Core;
+using FrooxEngine.UIX;
+using FrooxEngine;
+using HarmonyLib;
+using MonkeyLoader.Patching;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using EnumerableToolkit;
+using MonkeyLoader.Resonite;
+
+namespace ArrayEditing
+{
+    [HarmonyPatchCategory(nameof(SyncArrayEditor))]
+    [HarmonyPatch(typeof(SyncMemberEditorBuilder), nameof(SyncMemberEditorBuilder.BuildArray))]
+    internal sealed class SyncArrayEditor : ResoniteMonkey<SyncArrayEditor>
+    {
+        private static readonly MethodInfo _addLinearValueProxying = AccessTools.Method(typeof(SyncArrayEditor), nameof(AddLinearValueProxying));
+        private static readonly MethodInfo _addListReferenceProxying = AccessTools.Method(typeof(SyncArrayEditor), nameof(AddListReferenceProxying));
+        private static readonly MethodInfo _addListValueProxying = AccessTools.Method(typeof(SyncArrayEditor), nameof(AddListValueProxying));
+        private static readonly MethodInfo _addCurveValueProxying = AccessTools.Method(typeof(SyncArrayEditor), nameof(AddCurveValueProxying));
+        private static readonly Type _iWorldElementType = typeof(IWorldElement);
+        private static readonly Type _particleBurstType = typeof(ParticleBurst);
+
+        public override bool CanBeDisabled => true;
+
+        protected override IEnumerable<IFeaturePatch> GetFeaturePatches() => Enumerable.Empty<IFeaturePatch>();
+
+        private static void AddLinearValueProxying<T>(SyncArray<LinearKey<T>> array, SyncElementList<ValueGradientDriver<T>.Point> list)
+            where T : IEquatable<T>
+        {
+            foreach (var key in array)
+            {
+                var point = list.Add();
+                point.Position.Value = key.time;
+                point.Value.Value = key.value;
+            }
+
+            AddUpdateProxies(array, list, list.Elements);
+
+            list.ElementsAdded += (list, startIndex, count) =>
+            {
+                var addedElements = list.Elements.Skip(startIndex).Take(count).ToArray();
+                var buffer = addedElements.Select(point => new LinearKey<T>(point.Position, point.Value)).ToArray();
+
+                array.Insert(buffer, startIndex);
+                AddUpdateProxies(array, list, addedElements);
+            };
+
+            list.ElementsRemoved += (list, startIndex, count) => array.Remove(startIndex, count);
+        }
+
+        private static void AddListReferenceProxying<T>(SyncArray<T> array, SyncElementList<SyncRef<T>> list)
+            where T : class, IEquatable<T>, IWorldElement
+        {
+            foreach (var reference in array)
+            {
+                var syncRef = list.Add();
+                syncRef.Target = reference;
+            }
+
+            AddUpdateProxies(array, list, list.Elements);
+
+            list.ElementsAdded += (list, startIndex, count) =>
+            {
+                var addedElements = list.Elements.Skip(startIndex).Take(count).ToArray();
+                var buffer = addedElements.Select(syncRef => syncRef.Target).ToArray();
+
+                array.Insert(buffer, startIndex);
+                AddUpdateProxies(array, list, addedElements);
+            };
+
+            list.ElementsRemoved += (list, startIndex, count) => array.Remove(startIndex, count);
+        }
+
+        private static void AddListValueProxying<T>(SyncArray<T> array, SyncElementList<Sync<T>> list)
+            where T : IEquatable<T>
+        {
+            foreach (var value in array)
+            {
+                var sync = list.Add();
+                sync.Value = value;
+            }
+
+            AddUpdateProxies(array, list, list.Elements);
+
+            list.ElementsAdded += (list, startIndex, count) =>
+            {
+                var addedElements = list.Elements.Skip(startIndex).Take(count).ToArray();
+                var buffer = addedElements.Select(sync => sync.Value).ToArray();
+
+                array.Insert(buffer, startIndex);
+                AddUpdateProxies(array, list, addedElements);
+            };
+
+            list.ElementsRemoved += (list, startIndex, count) => array.Remove(startIndex, count);
+        }
+
+        private static void AddParticleBurstListProxying(SyncArray<LinearKey<ParticleBurst>> array, SyncElementList<ValueGradientDriver<int2>.Point> list)
+        {
+            foreach (var burst in array)
+            {
+                var point = list.Add();
+                point.Position.Value = burst.time;
+                point.Value.Value = new int2(burst.value.minCount, burst.value.maxCount);
+            }
+
+            AddUpdateProxies(array, list, list.Elements);
+
+            list.ElementsAdded += (list, startIndex, count) =>
+            {
+                var addedElements = list.Elements.Skip(startIndex).Take(count).ToArray();
+                var buffer = addedElements.Select(point => new LinearKey<ParticleBurst>(point.Position, new ParticleBurst() { minCount = point.Value.Value.x, maxCount = point.Value.Value.y })).ToArray();
+
+                array.Insert(buffer, startIndex);
+                AddUpdateProxies(array, list, addedElements);
+            };
+
+            list.ElementsRemoved += (list, startIndex, count) => array.Remove(startIndex, count);
+        }
+
+        private static void AddTubePointProxying(SyncArray<TubePoint> array, SyncElementList<ValueGradientDriver<float3>.Point> list)
+        {
+            foreach (var tubePoint in array)
+            {
+                var point = list.Add();
+                point.Position.Value = tubePoint.radius;
+                point.Value.Value = tubePoint.position;
+            }
+
+            AddUpdateProxies(array, list, list.Elements);
+
+            list.ElementsAdded += (list, startIndex, count) =>
+            {
+                var addedElements = list.Elements.Skip(startIndex).Take(count).ToArray();
+                var buffer = addedElements.Select(point => new TubePoint(point.Value.Value, point.Position.Value)).ToArray();
+
+                array.Insert(buffer, startIndex);
+                AddUpdateProxies(array, list, addedElements);
+            };
+
+            list.ElementsRemoved += (list, startIndex, count) => array.Remove(startIndex, count);
+        }
+
+        private static void AddCurveValueProxying<T>(SyncArray<CurveKey<T>> array, SyncElementList<ValueGradientDriver<T>.Point> list)
+            where T : IEquatable<T>
+        {
+            foreach (var key in array)
+            {
+                var point = list.Add();
+                point.Position.Value = key.time;
+                point.Value.Value = key.value;
+            }
+
+            AddUpdateProxies(array, list, list.Elements);
+
+            list.ElementsAdded += (list, startIndex, count) =>
+            {
+                var addedElements = list.Elements.Skip(startIndex).Take(count).ToArray();
+                var buffer = addedElements.Select(point => new CurveKey<T>(point.Position, point.Value)).ToArray();
+
+                array.Insert(buffer, startIndex);
+                AddUpdateProxies(array, list, addedElements);
+            };
+
+            list.ElementsRemoved += (list, startIndex, count) => array.Remove(startIndex, count);
+        }
+
+        private static void AddUpdateProxies<T>(SyncArray<LinearKey<T>> array,
+            SyncElementList<ValueGradientDriver<T>.Point> list, IEnumerable<ValueGradientDriver<T>.Point> elements)
+                    where T : IEquatable<T>
+        {
+            foreach (var point in elements)
+            {
+                point.Changed += syncObject =>
+                {
+                    var index = list.IndexOfElement(point);
+                    array[index] = new LinearKey<T>(point.Position, point.Value);
+                };
+            }
+        }
+
+        private static void AddUpdateProxies(SyncArray<LinearKey<ParticleBurst>> array,
+            SyncElementList<ValueGradientDriver<int2>.Point> list, IEnumerable<ValueGradientDriver<int2>.Point> elements)
+        {
+            foreach (var point in elements)
+            {
+                point.Changed += field =>
+                {
+                    var index = list.IndexOfElement(point);
+                    var key = new LinearKey<ParticleBurst>(point.Position, new ParticleBurst() { minCount = point.Value.Value.x, maxCount = point.Value.Value.y });
+                    array[index] = key;
+                };
+            }
+        }
+
+        private static void AddUpdateProxies<T>(SyncArray<T> array, SyncElementList<Sync<T>> list, IEnumerable<Sync<T>> elements)
+                    where T : IEquatable<T>
+        {
+            foreach (var sync in elements)
+            {
+                sync.OnValueChange += field =>
+                {
+                    var index = list.IndexOfElement(sync);
+                    array[index] = sync.Value;
+                };
+            }
+        }
+
+        private static void AddUpdateProxies<T>(SyncArray<T> array, SyncElementList<SyncRef<T>> list, IEnumerable<SyncRef<T>> elements)
+            where T : class, IEquatable<T>, IWorldElement
+        {
+            foreach (var sync in elements)
+            {
+                sync.OnValueChange += field =>
+                {
+                    var index = list.IndexOfElement(sync);
+                    array[index] = sync.Target;
+                };
+            }
+        }
+
+        private static void AddUpdateProxies(SyncArray<TubePoint> array, SyncElementList<ValueGradientDriver<float3>.Point> list, IEnumerable<ValueGradientDriver<float3>.Point> elements)
+        {
+            foreach (var point in elements)
+            {
+                point.Changed += field =>
+                {
+                    var index = list.IndexOfElement(point);
+                    var tubePoint = new TubePoint(point.Value.Value, point.Position.Value);
+                    array[index] = tubePoint;
+                };
+            }
+        }
+
+        private static void AddUpdateProxies<T>(SyncArray<CurveKey<T>> array,
+            SyncElementList<ValueGradientDriver<T>.Point> list, IEnumerable<ValueGradientDriver<T>.Point> elements)
+                    where T : IEquatable<T>
+        {
+            foreach (var point in elements)
+            {
+                point.Changed += syncObject =>
+                {
+                    var index = list.IndexOfElement(point);
+                    array[index] = new CurveKey<T>(point.Position, point.Value, array[index].leftTangent, array[index].rightTangent);
+                };
+            }
+        }
+
+        private static Component GetOrAttachComponent(Slot targetSlot, Type type, out bool attachedNew)
+        {
+            attachedNew = false;
+            if (targetSlot.GetComponent(type) is not Component comp)
+            {
+                comp = targetSlot.AttachComponent(type);
+                attachedNew = true;
+            }
+            return comp;
+        }
+
+        private static bool Prefix(ISyncArray array, string name, FieldInfo fieldInfo, UIBuilder ui, float labelSize)
+        {
+            if (!Enabled) return true;
+
+            if (!TryGetGenericParameters(typeof(SyncArray<>), array.GetType(), out var genericParameters))
+                return true;
+
+            var isSyncLinear = TryGetGenericParameters(typeof(SyncLinear<>), array.GetType(), out var syncLinearGenericParameters);
+
+            var isSyncCurve = TryGetGenericParameters(typeof(SyncCurve<>), array.GetType(), out var syncCurveGenericParameters);
+
+            var arrayType = genericParameters!.Value.First();
+            var syncLinearType = syncLinearGenericParameters?.First();
+            var syncCurveType = syncCurveGenericParameters?.First();
+
+            var isParticleBurst = syncLinearType == _particleBurstType;
+
+            if (isSyncLinear && isParticleBurst)
+                syncLinearType = typeof(int2);
+
+            var proxySlotName = $"{name}-{array.ReferenceID}-Proxy";
+            var proxiesSlot = ui.World.AssetsSlot;
+            if (proxiesSlot.FindChild(proxySlotName) is not Slot proxySlot)
+            {
+                proxySlot = proxiesSlot.AddSlot(proxySlotName);
+                array.FindNearestParent<IDestroyable>().Destroyed += (IDestroyable _) => proxySlot.Destroy();
+            }
+            proxySlot.DestroyWhenLocalUserLeaves();
+
+            ISyncList list;
+            FieldInfo listField;
+
+            if (isSyncLinear && SupportsLerp(syncLinearType!))
+            {
+                var gradientType = typeof(ValueGradientDriver<>).MakeGenericType(syncLinearType);
+                var gradient = GetOrAttachComponent(proxySlot, gradientType, out bool attachedNew);
+
+                list = (ISyncList)gradient.GetSyncMember(nameof(ValueGradientDriver<float>.Points));
+                listField = gradient.GetSyncMemberFieldInfo(nameof(ValueGradientDriver<float>.Points));
+
+                if (attachedNew)
+                {
+                    if (isParticleBurst)
+                        AddParticleBurstListProxying((SyncArray<LinearKey<ParticleBurst>>)array, (SyncElementList<ValueGradientDriver<int2>.Point>)list);
+                    else
+                        _addLinearValueProxying.MakeGenericMethod(syncLinearType).Invoke(null, new object[] { array, list });
+                }
+            }
+            else if (isSyncCurve && SupportsLerp(syncCurveType!))
+            {
+                var gradientType = typeof(ValueGradientDriver<>).MakeGenericType(syncCurveType);
+                var gradient = GetOrAttachComponent(proxySlot, gradientType, out bool attachedNew);
+
+                list = (ISyncList)gradient.GetSyncMember(nameof(ValueGradientDriver<float>.Points));
+                listField = gradient.GetSyncMemberFieldInfo(nameof(ValueGradientDriver<float>.Points));
+
+                if (attachedNew)
+                {
+                    _addCurveValueProxying.MakeGenericMethod(syncCurveType).Invoke(null, new object[] { array, list });
+                }
+            }
+            else
+            {
+                if (arrayType == typeof(TubePoint))
+                {
+                    var gradient = GetOrAttachComponent(proxySlot, typeof(ValueGradientDriver<float3>), out bool attachedNew);
+
+                    list = (ISyncList)gradient.GetSyncMember(nameof(ValueGradientDriver<float3>.Points));
+                    listField = gradient.GetSyncMemberFieldInfo(nameof(ValueGradientDriver<float3>.Points));
+
+                    if (attachedNew)
+                    {
+                        AddTubePointProxying((SyncArray<TubePoint>)array, (SyncElementList<ValueGradientDriver<float3>.Point>)list);
+                    }
+                }
+                else if (Coder.IsEnginePrimitive(arrayType))
+                {
+                    var multiplexerType = typeof(ValueMultiplexer<>).MakeGenericType(arrayType);
+                    var multiplexer = GetOrAttachComponent(proxySlot, multiplexerType, out bool attachedNew);
+                    list = (ISyncList)multiplexer.GetSyncMember(nameof(ValueMultiplexer<float>.Values));
+                    listField = multiplexer.GetSyncMemberFieldInfo(nameof(ValueMultiplexer<float>.Values));
+
+                    if (attachedNew)
+                        _addListValueProxying.MakeGenericMethod(arrayType).Invoke(null, new object[] { array, list });
+                }
+                else if (_iWorldElementType.IsAssignableFrom(arrayType))
+                {
+                    var multiplexerType = typeof(ReferenceMultiplexer<>).MakeGenericType(arrayType);
+                    var multiplexer = GetOrAttachComponent(proxySlot, multiplexerType, out bool attachedNew);
+                    list = (ISyncList)multiplexer.GetSyncMember(nameof(ReferenceMultiplexer<Slot>.References));
+                    listField = multiplexer.GetSyncMemberFieldInfo(nameof(ReferenceMultiplexer<Slot>.References));
+
+                    if (attachedNew)
+                        _addListReferenceProxying.MakeGenericMethod(arrayType).Invoke(null, new object[] { array, list });
+                }
+                else
+                {
+                    proxySlot.Destroy();
+                    return true;
+                }
+            }
+
+            ui.Panel().Slot.GetComponent<LayoutElement>();
+            var memberFieldSlot = SyncMemberEditorBuilder.GenerateMemberField(array, name, ui, labelSize);
+            ui.NestOut();
+            if (!array.IsDriven)
+            {
+                SyncMemberEditorBuilder.BuildList(list, name, listField, ui);
+                var listSlot = ui.Current;
+                listSlot.DestroyWhenLocalUserLeaves();
+                void ArrayChanged(IChangeable changeable)
+                {
+                    if (((ISyncArray)changeable).IsDriven)
+                    {
+                        listSlot.DestroyChildren();
+                        listSlot.Components.ToArray().Do((Component c) => c.Destroy());
+                        listSlot.AttachComponent<LayoutElement>().MinHeight.Value = 24f;
+                        var newUi = new UIBuilder(listSlot, listSlot);
+                        RadiantUI_Constants.SetupEditorStyle(newUi);
+                        newUi.Text("(array is driven)");
+                        proxySlot?.Destroy();
+                        array.Changed -= ArrayChanged;
+                    }
+                }
+                array.Changed += ArrayChanged;
+            }
+            else
+            {
+                LocaleString text = "(array is driven)";
+                ui.Text(in text);
+            }
+
+            return false;
+        }
+
+        private static bool SupportsLerp(Type type)
+        {
+            var coderType = typeof(Coder<>).MakeGenericType(type);
+            return Traverse.Create(coderType).Property<bool>(nameof(Coder<float>.SupportsLerp)).Value;
+        }
+
+        private static bool TryGetGenericParameters(Type baseType, Type concreteType, [NotNullWhen(true)] out Sequence<Type>? genericParameters)
+        {
+            genericParameters = null;
+
+            if (concreteType is null || baseType is null || !baseType.IsGenericType)
+                return false;
+
+            if (concreteType.IsGenericType && concreteType.GetGenericTypeDefinition() == baseType)
+            {
+                genericParameters = concreteType.GetGenericArguments();
+                return true;
+            }
+
+            return TryGetGenericParameters(baseType, concreteType.BaseType, out genericParameters);
+        }
+    }
+
+    internal sealed class ListUI_Improvements : ResoniteMonkey<ListUI_Improvements>
+    {
+        public override bool CanBeDisabled => true;
+
+        protected override IEnumerable<IFeaturePatch> GetFeaturePatches() => Enumerable.Empty<IFeaturePatch>();
+
+        [HarmonyPatchCategory(nameof(ListUI_Improvements))]
+        [HarmonyPatch(typeof(SyncMemberEditorBuilder), "GenerateMemberField")]
+        class SyncMemberEditorBuilder_GenerateMemberField_Patch
+        {
+            private static bool Prefix(ISyncMember member, string name, UIBuilder ui, float labelSize)
+            {
+                if (Enabled && member.Parent is ISyncList && member is SyncObject)
+                {
+                    ui.CurrentRect.Slot.AttachComponent<HorizontalLayout>();
+                    if (ui.CurrentRect.Slot.GetComponent<LayoutElement>() is LayoutElement layoutElement)
+                    {
+                        layoutElement.MinWidth.Value = 48f;
+                        layoutElement.FlexibleWidth.Value = -1f;
+                    }
+                }
+                return true;
+            }
+        }
+
+        [HarmonyPatchCategory(nameof(ListUI_Improvements))]
+        [HarmonyPatch(typeof(ListEditor), "BuildListElement")]
+        class ListEditor_BuildListElement_Patch
+        {
+            private static bool Prefix(ISyncList list, ISyncMember member, string name, UIBuilder ui)
+            {
+                if (Enabled)
+                {
+                    ui.Style.MinHeight = 24f;
+                }
+                return true;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonkeyLoader.ModTemplate/MonkeyLoader.ModTemplate.csproj b/ArrayEditing/ArrayEditing.csproj
similarity index 57%
rename from MonkeyLoader.ModTemplate/MonkeyLoader.ModTemplate.csproj
rename to ArrayEditing/ArrayEditing.csproj
index d67f18a..4f0c1ef 100644
--- a/MonkeyLoader.ModTemplate/MonkeyLoader.ModTemplate.csproj
+++ b/ArrayEditing/ArrayEditing.csproj
@@ -1,20 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <AssemblyTitle>MonkeyLoader.ModTemplate</AssemblyTitle>
-    <RootNamespace>MonkeyLoader.ModTemplate</RootNamespace>
+    <AssemblyTitle>ArrayEditing</AssemblyTitle>
+    <RootNamespace>ArrayEditing</RootNamespace>
   </PropertyGroup>
 
   <PropertyGroup>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <PackageId>MonkeyLoader.ModTemplate.Resonite</PackageId>
-    <Title>MonkeyLoader Resonite Mod Template</Title>
-    <Authors>Banane9</Authors>
-    <Version>0.4.0</Version>
-    <Description>This is a template for a Resonite MonkeyLoader mod.</Description>
+    <PackageId>ArrayEditing</PackageId>
+    <Title>Array Editing</Title>
+    <Authors>Banane9, Nytra</Authors>
+    <Version>1.0.0</Version>
+    <Description>Adds proxy list UI for editing arrays in inspectors. Also improves the look of list UI a bit.</Description>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
-    <PackageProjectUrl>https://github.com/ResoniteModdingGroup/MonkeyLoader.ModTemplate</PackageProjectUrl>
+    <PackageProjectUrl>https://github.com/Nytra/ResoniteArrayEditing</PackageProjectUrl>
     <PackageTags>mod; mods; monkeyloader; resonite</PackageTags>
-    <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage);AddExtraFilesToPackage</TargetsForTfmSpecificContentInPackage>
+    <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage)</TargetsForTfmSpecificContentInPackage>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -24,12 +24,6 @@
     <PackageValidationBaselineVersion>0.1.0-beta</PackageValidationBaselineVersion> -->
   </PropertyGroup>
 
-  <Target Name="AddExtraFilesToPackage">
-    <ItemGroup>
-      <TfmSpecificPackageFile Include="$(ProjectDir)..\MonkeyLoader.ModTemplate.PrePatcher\bin\$(Configuration)\$(TargetFramework)\MonkeyLoader.ModTemplate.PrePatcher.*" PackagePath="lib/$(TargetFramework)/pre-patchers/" />
-    </ItemGroup>
-  </Target>
-
   <Target Name="CopyPackage" AfterTargets="Pack">
     <Copy Condition="'$(CopyToLibraries)'=='true'" SourceFiles="$(OutputPath)..\$(PackageId).$(PackageVersion).nupkg" DestinationFiles="$(ResonitePath)\MonkeyLoader\Mods\$(PackageId).nupkg" />
     <Message Condition="'$(CopyToLibraries)'=='true'" Text="Copied '$(OutputPath)..\$(PackageId).$(PackageVersion).nupkg' to '$(ResonitePath)\MonkeyLoader\Mods\$(PackageId).nupkg'" Importance="high" />
@@ -41,29 +35,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="MonkeyLoader" Version="0.19.0-beta" />
+    <PackageReference Include="MonkeyLoader" Version="0.22.12-beta" />
     <PackageReference Include="MonkeyLoader.GamePacks.Unity" Version="0.6.0-beta" />
-    <PackageReference Include="MonkeyLoader.GamePacks.Resonite" Version="0.16.6-beta" GeneratePathProperty="true" />
+    <PackageReference Include="MonkeyLoader.GamePacks.Resonite" Version="0.19.2-beta" GeneratePathProperty="true" />
     <PackageReference Include="PolySharp" Version="1.14.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Resonite.Elements.Core" Version="1.0.2" />
-    <PackageReference Include="Resonite.FrooxEngine" Version="2024.6.11.74" />
+    <PackageReference Include="Resonite.Elements.Core" Version="1.2.1" />
+    <PackageReference Include="Resonite.FrooxEngine" Version="2024.8.6.1341" />
     <PackageReference Include="System.Text.Json" Version="8.0.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
-  
-  <ItemGroup>
-    <!-- Reference the pre-patcher assembly from the Game Pack because PackageReference is stupid -->
-    <Reference Include="MonkeyLoader.Resonite.Data">
-      <HintPath>$(PkgMonkeyLoader_GamePacks_Resonite)\lib\net462\pre-patchers\MonkeyLoader.Resonite.Data.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\MonkeyLoader.ModTemplate.PrePatcher\MonkeyLoader.ModTemplate.PrePatcher.csproj" PrivateAssets="All" />
-  </ItemGroup>
 </Project>
diff --git a/MonkeyLoader.ModTemplate/Locale/de.json b/ArrayEditing/Locale/de.json
similarity index 100%
rename from MonkeyLoader.ModTemplate/Locale/de.json
rename to ArrayEditing/Locale/de.json
diff --git a/MonkeyLoader.ModTemplate/Locale/en.json b/ArrayEditing/Locale/en.json
similarity index 100%
rename from MonkeyLoader.ModTemplate/Locale/en.json
rename to ArrayEditing/Locale/en.json
diff --git a/MonkeyLoader.ModTemplate/Locale/jp.json b/ArrayEditing/Locale/jp.json
similarity index 100%
rename from MonkeyLoader.ModTemplate/Locale/jp.json
rename to ArrayEditing/Locale/jp.json
diff --git a/Directory.Build.props b/Directory.Build.props
index c4ce13b..a06a6c5 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -39,5 +39,6 @@
     <ResonitePath Condition="Exists('C:\Program Files (x86)\Steam\steamapps\common\Resonite\')">C:\Program Files (x86)\Steam\steamapps\common\Resonite</ResonitePath>
     <ResonitePath Condition="Exists('$(HOME)/.steam/steam/steamapps/common/Resonite/')">$(HOME)/.steam/steam/steamapps/common/Resonite</ResonitePath>
     <ResonitePath Condition="Exists('D:/Files/Games/Resonite/app/')">D:/Files/Games/Resonite/app</ResonitePath>
+	<ResonitePath Condition="Exists('G:\SteamLibrary\steamapps\common\Resonite\')">G:\SteamLibrary\steamapps\common\Resonite</ResonitePath>
   </PropertyGroup>
 </Project>
diff --git a/MonkeyLoader.ModTemplate.PrePatcher/BasicPrePatcher.cs b/MonkeyLoader.ModTemplate.PrePatcher/BasicPrePatcher.cs
deleted file mode 100644
index ef5e25e..0000000
--- a/MonkeyLoader.ModTemplate.PrePatcher/BasicPrePatcher.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using MonkeyLoader.Patching;
-using MonkeyLoader.Resonite.Features.FrooxEngine;
-using Mono.Cecil.Cil;
-using Mono.Cecil.Rocks;
-using MonoMod.Utils;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MonkeyLoader.ModTemplate
-{
-    internal sealed class BasicPrePatcher : ConfiguredEarlyMonkey<BasicPrePatcher, MyConfig>
-    {
-        public static void HelloMethod()
-            => Logger.Info(() => $"Hello {ConfigSection.TargetName} from pre-patched-in SomeNameSpace.SomeType static constructor!");
-
-        // The options for these should be provided by your game's game pack.
-        protected override IEnumerable<IFeaturePatch> GetFeaturePatches()
-        {
-            yield return new FeaturePatch<FrooxEngine>(PatchCompatibility.HookOnly);
-        }
-
-        protected override IEnumerable<PrePatchTarget> GetPrePatchTargets()
-        {
-            yield return new PrePatchTarget(Feature<FrooxEngine>.Assembly, "FrooxEngine.Engine");
-        }
-
-        protected override bool Patch(PatchJob patchJob)
-        {
-            var engine = patchJob.Types.First();
-            var engineCCtor = engine.GetStaticConstructor();
-
-            var processor = engineCCtor.Body.GetILProcessor(); // using MonoMod.Utils; is important for this to work v
-            processor.InsertBefore(engineCCtor.Body.Instructions.First(), processor.Create(OpCodes.Call, typeof(BasicPrePatcher).GetMethod(nameof(HelloMethod))));
-
-            patchJob.Changes = true;
-            return true;
-        }
-    }
-}
\ No newline at end of file
diff --git a/MonkeyLoader.ModTemplate.PrePatcher/MonkeyLoader.ModTemplate.PrePatcher.csproj b/MonkeyLoader.ModTemplate.PrePatcher/MonkeyLoader.ModTemplate.PrePatcher.csproj
deleted file mode 100644
index 463c34f..0000000
--- a/MonkeyLoader.ModTemplate.PrePatcher/MonkeyLoader.ModTemplate.PrePatcher.csproj
+++ /dev/null
@@ -1,27 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <AssemblyTitle>MonkeyLoader.ModTemplate.PrePatcher</AssemblyTitle>
-    <RootNamespace>MonkeyLoader.ModTemplate</RootNamespace>
-  </PropertyGroup>
-  
-  <ItemGroup>
-    <PackageReference Include="MonkeyLoader" Version="0.19.0-beta" />
-    <!-- Prevent automatically referencing all DLLs from the Game Pack -->
-    <PackageReference Include="MonkeyLoader.GamePacks.Resonite" Version="0.16.6-beta" ExcludeAssets="compile; build; runtime; native" GeneratePathProperty="true" />
-    <PackageReference Include="PolySharp" Version="1.14.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="System.Text.Json" Version="8.0.4">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- Reference only the pre-patcher assembly from the Game Pack -->
-    <Reference Include="MonkeyLoader.Resonite.Data">
-      <HintPath>$(PkgMonkeyLoader_GamePacks_Resonite)\lib\net462\pre-patchers\MonkeyLoader.Resonite.Data.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-</Project>
diff --git a/MonkeyLoader.ModTemplate.PrePatcher/MyConfig.cs b/MonkeyLoader.ModTemplate.PrePatcher/MyConfig.cs
deleted file mode 100644
index 6d43841..0000000
--- a/MonkeyLoader.ModTemplate.PrePatcher/MyConfig.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using MonkeyLoader.Configuration;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MonkeyLoader.ModTemplate
-{
-    internal sealed class MyConfig : ConfigSection
-    {
-        private readonly DefiningConfigKey<string> _targetNameKey = new("TargetName", "Your name.", () => "World");
-
-        public override string Description => "This section contains my very useful config options.";
-
-        public override string Id => "Main";
-
-        /// <summary>
-        /// Gets or sets the name. Not strictly necessary, but makes it a little nicer to use.
-        /// </summary>
-        public string TargetName
-        {
-            get => _targetNameKey.GetValue()!;
-            set => _targetNameKey.SetValue(value);
-        }
-
-        public override Version Version { get; } = new Version(1, 0, 0);
-    }
-}
\ No newline at end of file
diff --git a/MonkeyLoader.ModTemplate/BasicPatcher.cs b/MonkeyLoader.ModTemplate/BasicPatcher.cs
deleted file mode 100644
index 41422ec..0000000
--- a/MonkeyLoader.ModTemplate/BasicPatcher.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using FrooxEngine.ProtoFlux;
-using HarmonyLib;
-using MonkeyLoader.Patching;
-using MonkeyLoader.Resonite;
-using MonkeyLoader.Resonite.Features.FrooxEngine;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MonkeyLoader.ModTemplate
-{
-    [HarmonyPatchCategory(nameof(BasicPatcher))]
-    [HarmonyPatch(typeof(ProtoFluxTool), nameof(ProtoFluxTool.OnAttach))]
-    internal class BasicPatcher : ResoniteMonkey<BasicPatcher>
-    {
-        // The options for these should be provided by your game's game pack.
-        protected override IEnumerable<IFeaturePatch> GetFeaturePatches()
-        {
-            yield return new FeaturePatch<ProtofluxTool>(PatchCompatibility.HookOnly);
-        }
-
-        private static void Postfix()
-        {
-            Logger.Info(() => "Postfix for ProtoFluxTool.OnAttach()!");
-        }
-    }
-}
\ No newline at end of file