Using settings manager and fixing some issues

MDMods · Mar 7, 2024 · 88e52b6 · 88e52b6
1 parent 8dc4792
commit 88e52b6
Show file tree

Hide file tree

Showing 5 changed files with 129 additions and 44 deletions.
diff --git a/Main.cs b/Main.cs
@@ -1,14 +1,22 @@
-using MelonLoader;
+using FadeIn.Managers;
+using MelonLoader;
 
 namespace FadeIn
 {
     public class Main : MelonMod
     {
-
         public override void OnInitializeMelon()
         {
             base.OnInitializeMelon();
+            SettingsManager.Load();
             LoggerInstance.Msg("FadeIn has loaded correctly!");
         }
+
+        public override void OnSceneWasLoaded(int buildIndex, string sceneName)
+        {
+            base.OnSceneWasLoaded(buildIndex, sceneName);
+            if (sceneName.Equals("GameMain")) return;
+            ModManager.ClearCoroutines();
+        }
     }
 }
diff --git a/Managers/ModManager.cs b/Managers/ModManager.cs
@@ -5,80 +5,83 @@
 using MelonLoader;
 using System.Collections;
 using UnityEngine;
+using static FadeIn.Managers.SettingsManager;
 
 namespace FadeIn.Managers
 {
     internal static class ModManager
     {
-        private static bool _enabled = false;
-        public static bool IsEnabled
+        private static readonly List<object> CoroutinesList = new();
+        public static void ClearCoroutines()
         {
-            get { return _enabled; }
-            set { _enabled = value; }
+            foreach (var coroutine in CoroutinesList) MelonCoroutines.Stop(coroutine);
+            CoroutinesList.Clear();
         }
 
         public static GameObject FadeToggle = null;
         public static StageBattleComponent SBC { get; set; } = null;
 
-        private static readonly float LowerPositionX = -1.8f;
-        private static readonly float LowerPositionR = 8.0f;
-        private static readonly float MinimalInitialX = 5.8f;
-        private static readonly float NoteInitial = 11.8f;
+
         //private static readonly WaitForSeconds WFS = new WaitForSeconds(0.05f);
         private static readonly WaitForSeconds WFS = null;
 
-        private static IEnumerator UpdateAlphaX(Skeleton sk, Bone x, float initialX)
+        private static void UpdateAlphaValue(Skeleton sk, float coordinate, float LowerLimit, float initial, float LowerPosition)
         {
-            float lowerLimit = Mathf.Min(MinimalInitialX, initialX);
-            while (sk.a > 0.01f && x.x > LowerPositionX)
-            {
-                if ((!SBC?.isInGame ?? true) || (SBC?.isPause ?? true)) yield return null;
+            if (coordinate > LowerLimit) return;
+            sk.a = Mathf.Clamp(
+                (coordinate - LowerPosition) / (initial - LowerPosition),
+                0f, sk.a);
+        }
 
-                if (x.x <= MinimalInitialX)
-                    sk.a = Mathf.Clamp((x.x - LowerPositionX) / (lowerLimit - LowerPositionX), 0f, 1f);
+        private static IEnumerator UpdateAlphaX(Skeleton sk, GameObject gameObject, Bone x, float initialX)
+        {
+            float lowerLimit = Mathf.Min(MinimalDistanceX, initialX);
+            while (sk.a > 0.01f && x.x > DissapearPositionX && gameObject)
+            {
+                UpdateAlphaValue(sk, x.x, MinimalDistanceX, lowerLimit, DissapearPositionX);
                 yield return WFS;
             }
             sk.a = 0f;
         }
 
-        private static IEnumerator UpdateAlphaR(Skeleton sk, Bone y, float initialR)
+        private static IEnumerator UpdateAlphaR(Skeleton sk, GameObject gameObject, Bone y, float initialR)
         {
-            while (sk.a > 0.01f && y.rotation > LowerPositionR)
+            while (sk.a > 0.01f && y.rotation > DissapearPositionR && gameObject)
             {
-                if ((!SBC?.isInGame ?? true) || (SBC?.isPause ?? true)) yield return null;
-
-                if (y.rotation <= 85f)
-                    sk.a = Mathf.Clamp((y.rotation - LowerPositionR) / (initialR - LowerPositionR), 0f, 1f);
+                UpdateAlphaValue(sk, y.rotation, MinimalDistanceR, initialR, DissapearPositionR);
                 yield return WFS;
             }
             sk.a = 0f;
         }
 
         private static IEnumerator UpdateAlphaNote(Skeleton sk, GameObject gameObject)
         {
-            Transform transform = gameObject.transform;
-            while (sk.a > 0.01f && transform.position.x > LowerPositionX)
-            {
-                if ((!SBC?.isInGame ?? true) || (SBC?.isPause ?? true)) yield return null;
+            //Waiting for the proper position
+            yield return null;
 
-                float x = transform.position.x;
-                if (x <= MinimalInitialX)
-                    sk.a = Mathf.Clamp((x - LowerPositionX) / (MinimalInitialX - LowerPositionX), 0f, 1f);
+
+            while (sk.a > 0.01f && gameObject)
+            {
+                if ((SBC?.isInGame ?? false) && (!SBC?.isPause ?? false))
+                {
+                    float x = gameObject?.transform?.position.x ?? -3f;
+                    UpdateAlphaValue(sk, x, MinimalDistanceX, MinimalDistanceX, DissapearPositionX);
+                }
                 yield return WFS;
             }
             sk.a = 0f;
         }
 
-        private static object AddCallBackEnemy(Bone xPos, Bone yPos, Skeleton sk)
+        private static void AddCallBackEnemy(Skeleton sk, GameObject gameObject, Bone xPos, Bone yPos)
         {
-            return MelonCoroutines.Start(yPos.rotation > 70f
-                    ? UpdateAlphaR(sk, yPos, yPos.rotation)
-                    : UpdateAlphaX(sk, xPos, xPos.x));
+            CoroutinesList.Add(MelonCoroutines.Start(yPos.rotation > 80f
+                    ? UpdateAlphaR(sk, gameObject, yPos, yPos.rotation)
+                    : UpdateAlphaX(sk, gameObject, xPos, xPos.x)));
         }
 
-        private static object AddCallBackNote(GameObject gameObject, Skeleton sk)
+        private static void AddCallBackNote(Skeleton sk, GameObject gameObject)
         {
-            return MelonCoroutines.Start(UpdateAlphaNote(sk, gameObject));
+            CoroutinesList.Add(MelonCoroutines.Start(UpdateAlphaNote(sk, gameObject)));
         }
 
         internal static float ProcessEnemy(BaseEnemyObjectController beoc, Skeleton sk)
@@ -90,25 +93,25 @@ internal static float ProcessEnemy(BaseEnemyObjectController beoc, Skeleton sk)
             // Music note particles
             if (beoc.TryGetComponent(out AirMusicNodeController note))
             {
-                ModManager.AddCallBackNote(note.gameObject, sk);
+                AddCallBackNote(sk, note.gameObject);
                 note.m_Fx.SetActive(false);
             }
             // Heart particles
             else if (beoc.TryGetComponent(out AirEnergyBottleController heart))
             {
-                ModManager.AddCallBackNote(heart.gameObject, sk);
+                AddCallBackNote(sk, heart.gameObject);
                 heart.m_Fx.SetActive(false);
             }
             else
             {
-                ModManager.AddCallBackEnemy(xPos, yPos, sk);
+                AddCallBackEnemy(sk, beoc.gameObject, xPos, yPos);
             }
 
             //Hearts on notes
             GameObject hpOnNote = beoc.m_Blood;
             if (!hpOnNote) return xPos.x;
 
-            ModManager.AddCallBackEnemy(xPos, yPos, hpOnNote.GetComponent<SkeletonAnimation>().skeleton);
+            AddCallBackEnemy(hpOnNote.GetComponent<SkeletonAnimation>().skeleton, beoc.gameObject, xPos, yPos);
             Transform heartFx = hpOnNote.transform.Find("fx");
 
             if (!heartFx) return xPos.x;

diff --git a/Managers/SettingsManager.cs b/Managers/SettingsManager.cs
@@ -0,0 +1,73 @@
+using MelonLoader;
+
+namespace FadeIn.Managers
+{
+    public enum Difficulties
+    {
+        Easy,
+        Medium,
+        Hard,
+    }
+
+    internal class SettingsManager
+    {
+        private static MelonPreferences_Entry<bool> _isEnabled;
+
+        internal static bool IsEnabled
+        {
+            get { return _isEnabled.Value; }
+            set { _isEnabled.Value = value; }
+        }
+
+        private static MelonPreferences_Entry<string> _difficulty;
+        internal static Difficulties Difficulty
+        {
+            get
+            {
+                return _difficulty.Value switch
+                {
+                    "Easy" => Difficulties.Easy,
+                    "Hard" => Difficulties.Hard,
+                    _ => Difficulties.Medium,
+                };
+            }
+        }
+        public static float DissapearPositionX { get; set; }
+        public static float DissapearPositionR { get; set; }
+        public static float MinimalDistanceX { get; set; }
+        public static float MinimalDistanceR { get; set; }
+
+        internal static void InitValues()
+        {
+            switch (Difficulty)
+            {
+                case Difficulties.Easy:
+                    DissapearPositionX = -1.8f;
+                    DissapearPositionR = 8f;
+                    break;
+
+                case Difficulties.Medium:
+                    DissapearPositionX = -0.9f;
+                    DissapearPositionR = 20f;
+                    break;
+
+                case Difficulties.Hard:
+                    DissapearPositionX = 0f;
+                    DissapearPositionR = 35f;
+                    break;
+            }
+            MinimalDistanceX = 5.8f;
+            MinimalDistanceR = 70f;
+
+        }
+
+        public static void Load()
+        {
+            MelonPreferences_Category settings = MelonPreferences.CreateCategory("FadeIn");
+            _isEnabled = settings.CreateEntry<bool>(nameof(IsEnabled), false);
+            _difficulty = settings.CreateEntry<string>(nameof(Difficulty), "Medium", description: "Options:\nEasy\nMedium\nHard");
+
+            InitValues();
+        }
+    }
+}
diff --git a/Patches/EnemyPatch.cs b/Patches/EnemyPatch.cs
@@ -14,7 +14,7 @@ internal static class EnemyPatch
         [HarmonyPostfix]
         public static void PostfixEnableVisible(BaseEnemyObjectController __instance)
         {
-            if (!ModManager.IsEnabled) return;
+            if (!SettingsManager.IsEnabled) return;
             Skeleton sk = __instance.m_SkeletonAnimation.skeleton;
             Transform parent = __instance.transform.parent;
 

diff --git a/Patches/TogglePatch.cs b/Patches/TogglePatch.cs
@@ -1,4 +1,5 @@
-using HarmonyLib;
+using FadeIn.Managers;
+using HarmonyLib;
 using Il2Cpp;
 using Il2CppAssets.Scripts.PeroTools.GeneralLocalization;
 using UnityEngine;
@@ -24,10 +25,10 @@ public static void Postfix(PnlPreparation __instance)
 
             Toggle toggleComp = FadeToggle.GetComponent<Toggle>();
             toggleComp.onValueChanged.AddListener((UnityAction<bool>)
-                ((bool val) => { IsEnabled = val; })
+                ((bool val) => { SettingsManager.IsEnabled = val; })
                 );
             toggleComp.group = null;
-            toggleComp.SetIsOnWithoutNotify(IsEnabled);
+            toggleComp.SetIsOnWithoutNotify(SettingsManager.IsEnabled);
 
             Text txt = FadeToggle.transform.Find("Txt").GetComponent<Text>();
             txt.text = "Fade In";