Add terrain extender patches

Author: Metious

TerrainPatcher.csproj

@@ -49,6 +49,8 @@
         <Compile Include="src/FileLoading.cs"/>
         <Compile Include="src/Patches.cs"/>
         <Compile Include="src/Options.cs"/>
+        <Compile Include="src\Array3Patches.cs" />
+        <Compile Include="src\WorldStreamerPatches.cs" />
     </ItemGroup>
     <Import Project="$(MSBuildBinPath)/Microsoft.CSharp.targets"/>
     <Target Name="CopyToTargetDir" AfterTargets="Build">

src/Array3Patches.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using HarmonyLib;
+using Nautilus.Utility;
+
+namespace TerrainPatcher
+{
+    // Allows entities to save and exist on negative batches
+    [HarmonyPatch(typeof(Array3<>))]
+    internal static class Array3Patches
+    {
+        private class NegativeEntityCell
+        {
+            public Dictionary<Int3, EntityCell> EntityCells { get; }
+
+            public NegativeEntityCell(Dictionary<Int3, EntityCell> entityCells)
+            {
+                EntityCells = entityCells;
+            }
+        }
+        
+        private static Dictionary<Array3<EntityCell>, NegativeEntityCell> _vanillaToNegativeArrays = new Dictionary<Array3<EntityCell>, NegativeEntityCell>();
+
+        internal static void Patch(Harmony harmony)
+        {
+            var type = typeof(Array3<>).MakeGenericType(typeof(EntityCell));
+            var getMethod = AccessTools.Method(type, "Get");
+            harmony.Patch(getMethod,
+                prefix: new HarmonyMethod(AccessTools.Method(typeof(Array3Patches), nameof(GetPrefix))));
+            var setMethod = AccessTools.Method(type, "Set");
+            harmony.Patch(setMethod,
+                prefix: new HarmonyMethod(AccessTools.Method(typeof(Array3Patches), nameof(SetPrefix))));
+
+            SaveUtils.RegisterOnQuitEvent(() => { _vanillaToNegativeArrays.Clear(); });
+        }
+
+        private static bool GetPrefix(Array3<EntityCell> __instance, int x, int y, int z, ref EntityCell __result)
+        {
+            var index = __instance.GetIndex(x, y, z);
+            if (index >= 0)
+            {
+                return true;
+            }
+
+            // At this point the index is negative, so we'll handle it ourselves.
+            if (_vanillaToNegativeArrays.TryGetValue(__instance, out var negativesArray) &&
+                negativesArray.EntityCells.TryGetValue(new Int3(x, y, z), out var entityCell))
+            {
+                __result = entityCell;
+                Mod.LogDebug($"Get negative entity cell for ({x},{y},{z})");
+                return false;
+            }
+
+            Mod.LogDebug($"Couldn't find negative entity cell for ({x},{y},{z})");
+            return false;
+        }
+
+        private static bool SetPrefix(Array3<EntityCell> __instance, int x, int y, int z, EntityCell value)
+        {
+            var index = __instance.GetIndex(x, y, z);
+            if (index >= 0)
+            {
+                return true;
+            }
+
+            // At this point the index is negative, so we'll set it to our collection.
+            if (!_vanillaToNegativeArrays.TryGetValue(__instance, out var negativeEntityCell))
+            {
+                negativeEntityCell = new NegativeEntityCell(new Dictionary<Int3, EntityCell>(Int3.equalityComparer));
+                _vanillaToNegativeArrays[__instance] = negativeEntityCell;
+            }
+
+            negativeEntityCell.EntityCells[new Int3(x, y, z)] = value;
+            Mod.LogDebug($"Set negative entity cell for ({x},{y},{z})");
+
+            return false;
+        }
+    }
+}

src/Patches.cs

@@ -13,6 +13,9 @@ internal static void Register()
             var harmony = new Harmony("Esper89.TerrainPatcher");
             harmony.PatchAll(typeof(LargeWorldStreamer_GetCompiledOctreesCachePath_Patch));
             harmony.PatchAll(typeof(BatchOctreesStreamer_GetPath_Patch));
+            harmony.PatchAll(typeof(LargeWorldStreamer_CheckBatch_Patches));
+            harmony.PatchAll(typeof(WorldStreamerPatches));
+            Array3Patches.Patch(harmony);
         }
 
         [HarmonyPatch(
@@ -73,5 +76,19 @@ private static bool SetResult(Int3 batchId, ref string result, bool runOriginal)
                 return true;
             }
         }
+        
+        // Permits any batch location
+        [HarmonyPatch(typeof(LargeWorldStreamer))]
+        internal static class LargeWorldStreamer_CheckBatch_Patches
+        {
+            [HarmonyPatch(nameof(LargeWorldStreamer.CheckBatch))]
+            [HarmonyPatch(nameof(LargeWorldStreamer.CheckRoot), typeof(int), typeof(int), typeof(int))]
+            [HarmonyPrefix]
+            private static bool AllowOutOfBounds(ref bool __result)
+            {
+                __result = true;
+                return false;
+            }
+        }
     }
 }

src/WorldStreamerPatches.cs

@@ -0,0 +1,104 @@
+using System.Collections.Generic;
+using System.Reflection.Emit;
+using HarmonyLib;
+using UnityEngine;
+using WorldStreaming;
+
+namespace TerrainPatcher
+{
+    [HarmonyPatch(typeof(WorldStreamer))]
+    internal static class WorldStreamerPatches
+    {
+        [HarmonyPatch(nameof(WorldStreamer.CreateStreamers))]
+        [HarmonyPrefix]
+        private static void CreateStreamersPrefix(WorldStreamer __instance)
+        {
+            // allows the streamer to stream octrees as far as the patched batches go
+            
+            var biggestBatch = BiggestBatch(TerrainRegistry.patchedBatches.Keys, __instance.settings.numOctrees) +
+                               __instance.settings.numOctreesPerBatch * (__instance.settings.numOctreesPerBatch * 2);
+            __instance.settings.numOctrees = biggestBatch;
+        }
+
+        [HarmonyPatch(nameof(WorldStreamer.CreateStreamers))]
+        [HarmonyTranspiler]
+        private static IEnumerable<CodeInstruction> CreateStreamersTranspiler(IEnumerable<CodeInstruction> instructions)
+        {
+            // Changes minimum and maximum center positions. Also necessary to stream batches
+            
+            var int3Zero = AccessTools.Field(typeof(Int3), nameof(Int3.zero));
+            var found = false;
+            var found2 = false;
+            foreach (var instruction in instructions)
+            {
+                if (instruction.Is(OpCodes.Ldsfld, int3Zero))
+                {
+                    yield return CodeInstruction.Call(typeof(WorldStreamerPatches), nameof(MinimumBoundary));
+                    found = true;
+                }
+                else if (instruction.Calls(AccessTools.Method(typeof(WorldStreamer),
+                             nameof(WorldStreamer.ParseStreamingSettings))))
+                {
+                    yield return instruction;
+                    yield return CodeInstruction.Call(typeof(WorldStreamerPatches), nameof(ParseStreamingSettings));
+                    found2 = true;
+                }
+                else
+                {
+                    yield return instruction;
+                }
+            }
+
+            if (found && found2)
+            {
+                Mod.LogDebug($"{nameof(CreateStreamersTranspiler)} has been patched successfully.");
+            }
+            else
+            {
+                Mod.LogError($"{nameof(CreateStreamersTranspiler)} failed patching.");
+            }
+        }
+
+        private static LargeWorldStreamer.Settings ParseStreamingSettings(LargeWorldStreamer.Settings settings)
+        {
+            var patchedBatches = TerrainRegistry.patchedBatches.Keys;
+            settings.octreesSettings.centerMin = SmallestBatch(patchedBatches) * 5 - 10;
+            settings.octreesSettings.centerMax = BiggestBatch(patchedBatches, settings.octreesSettings.centerMax) * 5 + 15;
+            return settings;
+        }
+
+        private static Int3 MinimumBoundary()
+        {
+            return SmallestBatch(TerrainRegistry.patchedBatches.Keys) * 5 - 10;
+        }
+
+        private static Int3 SmallestBatch(IEnumerable<Int3> batches)
+        {
+            var result = Int3.zero;
+
+            foreach (var batch in batches)
+            {
+                result = Int3.Min(result, batch);
+            }
+
+            var horizontalMin = Mathf.Min(result.x, result.z);
+
+            return new Int3(horizontalMin, result.y, horizontalMin);
+        }
+
+        private static Int3 BiggestBatch(IEnumerable<Int3> batches, Int3 minimumBatch)
+        {
+            var result = minimumBatch;
+
+            foreach (var batch in batches)
+            {
+                var batchSize = batch;
+                result = Int3.Max(result, batchSize);
+            }
+
+            var horizontalMax = Mathf.Max(result.x, result.z);
+
+            return new Int3(horizontalMax, result.y, horizontalMax);
+        }
+    }
+}