Refactor and Reorganize Patch Structure and Namespaces

Patch/Game/EndscreenLanternsPatch.cs

@@ -0,0 +1,73 @@
+using System.Diagnostics.CodeAnalysis;
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(EndscreenLanterns))]
+    // ReSharper disable once InconsistentNaming
+    public static class EndscreenLanternsPatch
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch("Show")]
+        [SuppressMessage("ReSharper", "InconsistentNaming")]
+        public static bool PrefixShow(EndscreenLanterns __instance, ref int __result)
+        {
+            if (!RenderManager.IsActive) return true;
+            if (__instance != null)
+            {
+                __instance.Hide();
+            }
+            __result = 0; // Return 0 lanterns shown
+            return false; // Skip original Show method
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("Hide")]
+        [SuppressMessage("ReSharper", "InconsistentNaming")]
+        public static void PrefixHide(EndscreenLanterns __instance)
+        {
+            if (__instance == null) return;
+
+            var traverse = Traverse.Create(__instance);
+            
+            // Kill lampSequences (private Sequence[] lampSequences) via reflection
+            var lampSequencesField = traverse.Field("lampSequences");
+            var lampSequencesObj = lampSequencesField.GetValue();
+            if (lampSequencesObj is System.Array lampSequencesArray)
+            {
+                for (var i = 0; i < lampSequencesArray.Length; i++)
+                {
+                    var item = lampSequencesArray.GetValue(i);
+                    if (item == null) continue;
+                    try
+                    {
+                        var killMethod = item.GetType().GetMethod("Kill", new[] { typeof(bool) });
+                        killMethod?.Invoke(item, new object[] { false });
+                    }
+                    catch
+                    {
+                        // Ignore reflection errors
+                    }
+                    lampSequencesArray.SetValue(null, i);
+                }
+            }
+
+            // Kill chainSequence (private Sequence chainSequence) via reflection
+            var chainSequenceField = traverse.Field("chainSequence");
+            var chainSequenceObj = chainSequenceField.GetValue();
+            if (chainSequenceObj == null) return;
+            
+            try
+            {
+                var killMethod = chainSequenceObj.GetType().GetMethod("Kill", new[] { typeof(bool) });
+                killMethod?.Invoke(chainSequenceObj, new object[] { false });
+            }
+            catch
+            {
+                // Ignore reflection errors
+            }
+            chainSequenceField.SetValue(null);
+        }
+    }
+}

Patch/Game/PersistencePatch.cs

@@ -0,0 +1,20 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(Persistence), "skipIntroBehavior", MethodType.Getter)]
+    public static class PersistencePatch
+    {
+        // ReSharper disable once InconsistentNaming
+        public static void Postfix(ref SkipIntroBehavior __result)
+        {
+            if (RenderManager.IsActive && 
+                scrConductor.instance != null && 
+                !scrConductor.instance.hasSongStarted)
+            {
+                __result = SkipIntroBehavior.Off;
+            }
+        }
+    }
+}

Patch/Game/scnEditorPatch.cs

@@ -0,0 +1,44 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scnEditor))]
+    // ReSharper disable once InconsistentNaming
+    public static class scnEditorPatch
+    {
+        [HarmonyPostfix]
+        [HarmonyPatch("Start")]
+        // ReSharper disable once InconsistentNaming
+        public static void AddButtonRender(scnEditor __instance)
+        {
+            var cloneTarget = __instance.buttonExit!.gameObject;
+            var buttonContainer = cloneTarget.transform.parent!;
+            
+            var buttonObj = Object.Instantiate(cloneTarget, buttonContainer)!;
+            buttonObj.name = "buttonRender";
+            
+            var button = buttonObj.GetComponent<Button>()!;
+            // Clear persistent and non-persistent listeners from the original button
+            button.onClick = new Button.ButtonClickedEvent();
+            button.onClick.AddListener(RenderManager.StartRender);
+            
+            // The button root has an Image component for the background (rounded box).
+            // We want to change the icon sprite, which is on a child GameObject.
+            var images = buttonObj.GetComponentsInChildren<Image>();
+            if (images.Length <= 1) return;
+            
+            // ReSharper disable once Unity.UnknownResource
+            // images[0] is the background on the root, images[1] is the icon on the child
+            var sprite = Resources.Load<Sprite>("LevelEditor/LevelEvents/MoveCamera");
+            if (sprite != null)
+            {
+                var iconImage = images[1];
+                iconImage.sprite = sprite;
+                iconImage.rectTransform.sizeDelta = new Vector2(24, 24);
+            }
+        }
+    }
+}

Patch/Game/scrCameraPatch.cs

@@ -0,0 +1,21 @@
+using System.Diagnostics.CodeAnalysis;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrCamera), "SetCustomFrameRate")]
+    // ReSharper disable once InconsistentNaming
+    public class scrCameraPatch
+    {
+        [SuppressMessage("ReSharper", "InconsistentNaming")]
+        private static bool Prefix(scrCamera __instance, bool enable, float frame)
+        {
+            // There is an issue that `mainTexture.Release` triggers even if `mainTexture` is `camRT`, so mod tries to fix it
+            if (enable || __instance.enableCustomFPS != enable) return true;
+            
+            __instance.enableCustomFPS = enable;
+            __instance.frameRate = frame;
+            return false;
+        }
+    }
+}

Patch/Game/scrControllerPatch.cs

@@ -0,0 +1,45 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrController))]
+    // ReSharper disable once InconsistentNaming
+    public static class scrControllerPatch
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch("TogglePauseGame")]
+        public static bool PreventPause()
+        {
+            return !RenderManager.IsActive;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("PortalTravelAction")]
+        public static bool PreventPortalTravel()
+        {
+            return !RenderManager.IsActive;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("FailAction")]
+        public static bool PreventFailAction()
+        {
+            return !RenderManager.IsActive;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("Fail2Action")]
+        public static bool PreventFail2Action()
+        {
+            return !RenderManager.IsActive;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("OnPlayerDied")]
+        public static bool PreventPlayerDied()
+        {
+            return !RenderManager.IsActive;
+        }
+    }
+}

Patch/Game/scrDecorationPatch.cs

@@ -0,0 +1,41 @@
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrDecoration))]
+    // ReSharper disable once InconsistentNaming
+    public static class scrDecorationPatch
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch("SetRotation")]
+        // ReSharper disable once InconsistentNaming
+        public static bool SetRotationPrefix(scrDecoration __instance)
+        {
+            return __instance != null && __instance && __instance.pivotTrans != null;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("SetScale")]
+        // ReSharper disable once InconsistentNaming
+        public static bool SetScalePrefix(scrDecoration __instance)
+        {
+            return __instance != null && __instance && __instance.pivotTrans != null;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("SetOpacity")]
+        // ReSharper disable once InconsistentNaming
+        public static bool SetOpacityPrefix(scrDecoration __instance)
+        {
+            return __instance != null && __instance;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch("UpdatePosition")]
+        // ReSharper disable once InconsistentNaming
+        public static bool UpdatePositionPrefix(scrDecoration __instance)
+        {
+            return __instance != null && __instance && __instance.pivotTrans != null;
+        }
+    }
+}

Patch/Game/scrHitTextManagerPatch.cs

@@ -0,0 +1,15 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrHitTextManager), "ShowHitText")]
+    // ReSharper disable once InconsistentNaming
+    public class scrHitTextManagerPatch
+    {
+        public static bool Prefix()
+        {
+            return !RenderManager.IsActive || RenderManager.Instance is { Configuration: { ShowHitText: true } };
+        }
+    }
+}

Patch/Game/scrMistakesManagerPatch.cs

@@ -0,0 +1,17 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrMistakesManager))]
+    // ReSharper disable once InconsistentNaming
+    public static class scrMistakesManagerPatch
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch("SaveCustom")]
+        public static bool PreventSaveCustom()
+        {
+            return !RenderManager.IsActive;
+        }
+    }
+}

Patch/Game/scrPlayerManagerPatch.cs

@@ -0,0 +1,21 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrPlayerManager))]
+    // ReSharper disable once InconsistentNaming
+    public static class scrPlayerManagerPatch
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch("AnyValidInputWasTriggered")]
+        // ReSharper disable once InconsistentNaming
+        private static bool IgnoreInput(ref bool __result)
+        {
+            if (!RenderManager.IsActive) return true;
+
+            __result = RenderManager.Instance && RenderManager.Instance.frameCount == 0 && RenderManager.Instance.countdown == 0;
+            return false;
+        }
+    }
+}

Patch/Game/scrPortalParticlesPatch.cs

@@ -0,0 +1,27 @@
+using HarmonyLib;
+using UnityEngine;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrPortalParticles))]
+    // ReSharper disable once InconsistentNaming
+    public static class scrPortalParticlesPatch
+    {
+        [HarmonyPostfix]
+        [HarmonyPatch("Start")]
+        // ReSharper disable once InconsistentNaming
+        public static void Postfix(scrPortalParticles __instance)
+        {
+            if (__instance == null) return;
+            
+            var particleSystems = __instance.GetComponentsInChildren<ParticleSystem>(true);
+            foreach (var ps in particleSystems)
+            {
+                if (ps == null) continue;
+                
+                var main = ps.main;
+                main.useUnscaledTime = false;
+            }
+        }
+    }
+}

Patch/Game/scrPressToStartPatch.cs

@@ -0,0 +1,20 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrPressToStart))]
+    // ReSharper disable once InconsistentNaming
+    public class scrPressToStartPatch
+    {
+        [HarmonyPrefix]
+        [HarmonyPatch("ShowText")]
+        private static bool PreventShowText()
+        {
+            if (!RenderManager.Instance || !RenderManager.Instance.skipPressToStart) return true;
+
+            RenderManager.Instance.skipPressToStart = false;
+            return false;
+        }
+    }
+}

Patch/Game/scrShowIfDebugPatch.cs

@@ -0,0 +1,37 @@
+using System.Diagnostics.CodeAnalysis;
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrShowIfDebug))]
+    // ReSharper disable once InconsistentNaming
+    public static class scrShowIfDebugPatch
+    {
+        [HarmonyPostfix]
+        [HarmonyPatch("Update")]
+        [SuppressMessage("ReSharper", "InconsistentNaming")]
+        private static void IgnoreInput(Text ___txt, Color ___defaultColor)
+        {
+            if (!RenderManager.IsActive) return;
+
+            ___txt.text = "Render";
+            if (RenderManager.Instance)
+            {
+                if (RenderManager.Instance.countdown > 0) ___txt.text = $"Render in {RenderManager.Instance.countdown}s..";
+
+                if (RenderManager.Instance.wonFrame != -1)
+                {
+                    var elapsedFrames = RenderManager.Instance.frameCount - RenderManager.Instance.wonFrame;
+                    var remainingTime = RenderManager.Instance.Configuration.EndWaitTime - elapsedFrames / RenderManager.Instance.Configuration.TargetFPS;
+                    if (remainingTime < 0) remainingTime = 0;
+                    ___txt.text += $"\nWaiting for {remainingTime:F1}s..";
+                }
+            }
+            
+            ___txt.color = ___defaultColor;
+        }
+    }
+}

Patch/Game/scrUIControllerPatch.cs

@@ -0,0 +1,21 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game
+{
+    [HarmonyPatch(typeof(scrUIController))]
+    // ReSharper disable once InconsistentNaming
+    public class scrUIControllerPatch
+    {
+        [HarmonyPostfix]
+        [HarmonyPatch("ShowEndscreenLanterns")]
+        // ReSharper disable once InconsistentNaming
+        public static void PreventEndscreenLanternsPostfix(scrUIController __instance)
+        {
+            if (RenderManager.IsActive && __instance != null)
+            {
+                __instance.HideEndscreenLanterns();
+            }
+        }
+    }
+}