Remove all statics from ModLoader

valkyrienyanko · valkyrienyanko · commit 3898cf49b3d1 · 2022-05-10T13:36:40.000-05:00
diff --git a/Scenes/Prefabs/ModLoader.tscn b/Scenes/Prefabs/ModLoader.tscn
@@ -12,9 +12,6 @@ size_flags_horizontal = 0
 size_flags_vertical = 0
 theme = ExtResource( 3 )
 script = ExtResource( 1 )
-__meta__ = {
-"_edit_use_anchors_": false
-}
 NodePathModList = NodePath("VBoxContainer/Mod Loader Info/Mod List/Mod List/MarginContainer/PanelContainer/ScrollContainer/Mods")
 NodePathModName = NodePath("VBoxContainer/Mod Loader Info/Mod Info/Mod Information/Mod Name")
 NodePathModGameVersions = NodePath("VBoxContainer/Mod Loader Info/Mod Info/Mod Information/MarginContainer2/VBoxContainer/Game Versions")
@@ -219,8 +216,10 @@ scroll_following = true
 selection_enabled = true
 
 [node name="FileDialog" type="FileDialog" parent="."]
-margin_right = 282.0
-margin_bottom = 131.0
+margin_left = 1.0
+margin_top = 1.0
+margin_right = 599.0
+margin_bottom = 499.0
 
 [connection signal="pressed" from="VBoxContainer/Mod Loader Info/Mod List/Mod List/HBoxContainer/Refresh" to="." method="_on_Refresh_pressed"]
 [connection signal="pressed" from="VBoxContainer/Mod Loader Info/Mod List/Mod List/HBoxContainer/Load Mods" to="." method="_on_Load_Mods_pressed"]
diff --git a/Scenes/Scenes/Menu.tscn b/Scenes/Scenes/Menu.tscn
@@ -15,9 +15,6 @@ anchor_right = 1.0
 anchor_bottom = 1.0
 theme = ExtResource( 4 )
 script = ExtResource( 5 )
-__meta__ = {
-"_edit_use_anchors_": false
-}
 NodePathSetupOnlineUsernamePopup = NodePath("Set Online Username Popup")
 
 [node name="PanelContainer" type="PanelContainer" parent="."]
@@ -50,7 +47,7 @@ anchor_right = 0.0
 anchor_bottom = 0.0
 margin_left = 604.0
 margin_right = 1004.0
-margin_bottom = 212.0
+margin_bottom = 213.0
 
 [node name="VBoxContainer" type="VBoxContainer" parent="PanelContainer"]
 margin_left = 474.0
diff --git a/Scripts/Msc/UIPopupFileDialogMods.cs b/Scripts/Msc/UIPopupFileDialogMods.cs
@@ -15,7 +15,7 @@ public override void _Ready()
 
         public void Open()
         {
-            FileManager.CurrentDir = ModLoader.ModLoader.PathMods;
+            FileManager.CurrentDir = GameManager.ModLoader.PathMods;
             FileManager.PopupCentered();
         }
 
diff --git a/Scripts/Scenes/Game/SceneGame.cs b/Scripts/Scenes/Game/SceneGame.cs
@@ -1,5 +1,4 @@
 using Godot;
-using GodotModules.ModLoader;
 using GodotModules.Netcode;
 using GodotModules.Netcode.Client;
 using GodotModules.Netcode.Server;
@@ -37,17 +36,17 @@ public override void _Ready()
             AddChild(bullet);
 
             // set game definitions
-            ModLoader.Script.Globals["Player", "setHealth"] = (Action<int>)Player.SetHealth;
+            GameManager.ModLoader.Script.Globals["Player", "setHealth"] = (Action<int>)Player.SetHealth;
 
-            ModLoader.Call("OnGameInit");
+            GameManager.ModLoader.Call("OnGameInit");
 
             if (NetworkManager.IsMultiplayer())
                 InitMultiplayerStuff();
         }
 
         public override void _PhysicsProcess(float delta)
         {
-            ModLoader.Call("OnGameUpdate", delta);
+            GameManager.ModLoader.Call("OnGameUpdate", delta);
 
             if (SceneManager.PrevSceneName == "Menu") // singleplayer
                 return;
diff --git a/Scripts/Scenes/Main/GameManager.cs b/Scripts/Scenes/Main/GameManager.cs
@@ -8,8 +8,8 @@ namespace GodotModules
     public class GameManager : Node
     {
         [Export] public readonly NodePath NodePathGameConsole;
+        public static ModLoader ModLoader { get; set; }
         public static UIGameConsole GameConsole { get; set; }
-
         public static GodotCommands GodotCommands { get; set; }
 
         public static string GameName = "Godot Modules";
@@ -21,6 +21,9 @@ public override void _Ready()
             GameTree = GetTree();
             GameConsole = GetNode<UIGameConsole>(NodePathGameConsole);
             GodotCommands = new GodotCommands();
+            ModLoader = new ModLoader();
+            ModLoader.Init();
+            ModLoader.LoadMods();
         }
 
         public override async void _Process(float delta)
diff --git a/Scripts/Scenes/Menu/ModLoader.cs b/Scripts/Scenes/Menu/ModLoader.cs
@@ -4,19 +4,19 @@
 
 using System.IO;
 
-namespace GodotModules.ModLoader
+namespace GodotModules
 {
     public class ModLoader
     {
-        public static List<Mod> LoadedMods = new List<Mod>();
-        public static Dictionary<string, Mod> ModInfo = new Dictionary<string, Mod>();
-        private static MoonSharpVsCodeDebugServer DebugServer { get; set; }
-        public static string PathModsEnabled { get; set; }
-        public static string PathMods { get; set; }
-        public static Script Script { get; set; }
-        public static string LuaScriptsPath = "";
-
-        public static void Init()
+        public List<Mod> LoadedMods = new List<Mod>();
+        public Dictionary<string, Mod> ModInfo = new Dictionary<string, Mod>();
+        private MoonSharpVsCodeDebugServer DebugServer { get; set; }
+        public string PathModsEnabled { get; set; }
+        public string PathMods { get; set; }
+        public Script Script { get; set; }
+        public string LuaScriptsPath = "";
+
+        public void Init()
         {
             PathMods = Path.Combine(GameManager.GetGameDataPath(), "Mods");
             PathModsEnabled = Path.Combine(PathMods, "enabled.json");
@@ -33,7 +33,7 @@ public static void Init()
             SortMods();
         }
 
-        public static void SortMods()
+        public void SortMods()
         {
             LoadedMods.Clear();
             ModInfo = FindAllMods();
@@ -57,7 +57,7 @@ public static void SortMods()
             });
         }
 
-        public static void LoadMods()
+        public void LoadMods()
         {
             UIModLoader.Instance.ClearLog();
 
@@ -83,7 +83,7 @@ public static void LoadMods()
                 UIModLoader.Instance.Log($"{modLoadedCount} mods have loaded successfully");
         }
 
-        private static void DisableModsWithLackingDependencies()
+        private void DisableModsWithLackingDependencies()
         {
             var modsToDisable = new List<ModInfo>();
 
@@ -99,7 +99,7 @@ private static void DisableModsWithLackingDependencies()
                 mod.Enabled = false;
         }
 
-        private static void CheckAllDependenciesEnabled(ModInfo firstMod, ModInfo modInfo, List<string> checkedMods, ref List<ModInfo> modsToDisable)
+        private void CheckAllDependenciesEnabled(ModInfo firstMod, ModInfo modInfo, List<string> checkedMods, ref List<ModInfo> modsToDisable)
         {
             foreach (var dependency in modInfo.Dependencies)
             {
@@ -117,7 +117,7 @@ private static void CheckAllDependenciesEnabled(ModInfo firstMod, ModInfo modInf
             }
         }
 
-        public static void Call(string v, params object[] args)
+        public void Call(string v, params object[] args)
         {
             try
             {
@@ -130,7 +130,7 @@ public static void Call(string v, params object[] args)
             }
         }
 
-        public static void SetModsEnabled()
+        public void SetModsEnabled()
         {
             var modsEnabled = new Dictionary<string, bool>();
             foreach (var mod in ModInfo)
@@ -139,7 +139,7 @@ public static void SetModsEnabled()
             File.WriteAllText(PathModsEnabled, JsonConvert.SerializeObject(modsEnabled, Formatting.Indented));
         }
 
-        public static void GetModsEnabled()
+        public void GetModsEnabled()
         {
             if (!File.Exists(PathModsEnabled))
                 return;
@@ -152,13 +152,13 @@ public static void GetModsEnabled()
             }
         }
 
-        private static void Log(object obj)
+        private void Log(object obj)
         {
             Logger.Log($"[ModLoader]: {obj}");
             UIModLoader.Instance.Log($"{obj}");
         }
 
-        private static void LoadLuaScripts(string directory)
+        private void LoadLuaScripts(string directory)
         {
             GodotFileManager.LoadDir(directory, (dir, fileName) =>
             {
@@ -182,15 +182,15 @@ private static void LoadLuaScripts(string directory)
             });
         }
 
-        private static void SetupModsEnabled()
+        private void SetupModsEnabled()
         {
             if (File.Exists(PathModsEnabled))
                 return;
 
             File.WriteAllText(PathModsEnabled, "{}");
         }
 
-        private static Dictionary<string, Mod> FindAllMods()
+        private Dictionary<string, Mod> FindAllMods()
         {
             var mods = new Dictionary<string, Mod>();
             var modFolders = Directory.GetDirectories(PathMods);
@@ -233,13 +233,13 @@ private static Dictionary<string, Mod> FindAllMods()
             return mods;
         }
 
-        private static void AddDependencyToLoadedMods(int modIndex, string dependency)
+        private void AddDependencyToLoadedMods(int modIndex, string dependency)
         {
             if (!LoadedMods.Contains(ModInfo[dependency]))
                 LoadedMods.Insert(modIndex, ModInfo[dependency]);
         }
 
-        private static void LoadMod(Mod mod, ref int modLoadedCount)
+        private void LoadMod(Mod mod, ref int modLoadedCount)
         {
             try
             {
@@ -255,15 +255,15 @@ private static void LoadMod(Mod mod, ref int modLoadedCount)
             }
         }
 
-        private static bool ModHasName(ModInfo modInfo) => modInfo.Name != null;
+        private bool ModHasName(ModInfo modInfo) => modInfo.Name != null;
 
-        private static bool RequiredModFilesExist(string folder, string pathInfo, string pathScriptLua) => File.Exists(pathInfo) && File.Exists(pathScriptLua);
+        private bool RequiredModFilesExist(string folder, string pathInfo, string pathScriptLua) => File.Exists(pathInfo) && File.Exists(pathScriptLua);
 
-        private static bool IsModMissingDependency(string dependency) => !ModInfo.ContainsKey(dependency);
+        private bool IsModMissingDependency(string dependency) => !ModInfo.ContainsKey(dependency);
 
-        private static bool ModHasDependency(string dependency) => ModInfo.ContainsKey(dependency);
+        private bool ModHasDependency(string dependency) => ModInfo.ContainsKey(dependency);
 
-        private static bool ModHasAllDependenciesEnabled(Mod mod)
+        private bool ModHasAllDependenciesEnabled(Mod mod)
         {
             var allDependenciesEnabled = true;
 
diff --git a/Scripts/Scenes/Menu/UIModInfo.cs b/Scripts/Scenes/Menu/UIModInfo.cs
@@ -1,6 +1,6 @@
 using Godot;
 
-namespace GodotModules.ModLoader
+namespace GodotModules
 {
     public class UIModInfo : Control
     {
@@ -43,7 +43,7 @@ private void _on_Enabled_pressed()
             var modName = BtnMod.Text;
 
             BtnModEnabled.Text = Enabled ? "[x]" : "[ ]";
-            ModLoader.ModInfo[modName].ModInfo.Enabled = Enabled;
+            GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled = Enabled;
 
             if (DisplayedInDependencies)
                 UIModLoader.Instance.ModInfoList[modName].SetModEnabled(Enabled);
diff --git a/Scripts/Scenes/Menu/UIModLoader.cs b/Scripts/Scenes/Menu/UIModLoader.cs
@@ -2,7 +2,7 @@
 using System;
 using System.Diagnostics;
 
-namespace GodotModules.ModLoader
+namespace GodotModules
 {
     public class UIModLoader : Control
     {
@@ -31,7 +31,7 @@ public class UIModLoader : Control
         // logger
         private RichTextLabel Logger { get; set; }
 
-        public override void _Ready()
+        public override async void _Ready()
         {
             Instance = this;
             ModList = GetNode<VBoxContainer>(NodePathModList);
@@ -46,8 +46,8 @@ public override void _Ready()
             ModDescription.Text = "";
             Logger.Clear();
 
-            ModLoader.Init();
-            ModLoader.LoadMods();
+            while (GameManager.ModLoader == null) // this is ugly
+                await Task.Delay(1);
 
             DisplayMods();
         }
@@ -61,7 +61,7 @@ public void UpdateModInfo(string name)
             foreach (Node node in ModDependencies.GetChildren())
                 node.QueueFree();
 
-            var modInfo = ModLoader.ModInfo[name].ModInfo;
+            var modInfo = GameManager.ModLoader.ModInfo[name].ModInfo;
 
             ModName.Text = name;
 
@@ -86,24 +86,24 @@ public void UpdateModInfo(string name)
 
         public void DisplayMods()
         {
-            ModLoader.LoadedMods.ForEach(mod =>
+            GameManager.ModLoader.LoadedMods.ForEach(mod =>
             {
                 var modInfo = CreateModInfoInstance(mod.ModInfo.Name);
                 ModList.AddChild(modInfo);
                 ModInfoList[mod.ModInfo.Name] = modInfo;
             });
 
-            if (ModLoader.LoadedMods.Count > 0)
-                UpdateModInfo(ModLoader.LoadedMods[0].ModInfo.Name);
+            if (GameManager.ModLoader.LoadedMods.Count > 0)
+                UpdateModInfo(GameManager.ModLoader.LoadedMods[0].ModInfo.Name);
         }
 
         private UIModInfo CreateModInfoInstance(string modName)
         {
             var instance = Prefabs.ModInfo.Instance<UIModInfo>();
             instance.SetModName(modName);
 
-            if (ModLoader.ModInfo[modName].ModInfo.Enabled)
-                instance.SetModEnabled(ModLoader.ModInfo[modName].ModInfo.Enabled);
+            if (GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled)
+                instance.SetModEnabled(GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled);
             else
                 instance.SetModEnabled(false);
 
@@ -112,12 +112,12 @@ private UIModInfo CreateModInfoInstance(string modName)
 
         private void _on_Refresh_pressed()
         {
-            ModLoader.SetModsEnabled();
+            GameManager.ModLoader.SetModsEnabled();
 
             foreach (Node node in ModList.GetChildren())
                 node.QueueFree();
 
-            ModLoader.SortMods();
+            GameManager.ModLoader.SortMods();
             DisplayMods();
         }
 
@@ -128,11 +128,11 @@ private void _on_Load_Mods_pressed()
                 var modName = info.ModName;
                 var modEnabled = info.Enabled;
 
-                ModLoader.ModInfo[modName].ModInfo.Enabled = modEnabled;
+                GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled = modEnabled;
             }
 
-            ModLoader.SetModsEnabled();
-            ModLoader.LoadMods();
+            GameManager.ModLoader.SetModsEnabled();
+            GameManager.ModLoader.LoadMods();
         }
 
         private void _on_Open_Mods_Folder_pressed()
@@ -145,7 +145,7 @@ private void _on_Open_Mods_Folder_pressed()
             {
                 using (Process myProcess = new Process())
                 {
-                    myProcess.StartInfo.FileName = ModLoader.PathMods;
+                    myProcess.StartInfo.FileName = GameManager.ModLoader.PathMods;
                     myProcess.Start();
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public override void _Ready()`
`15`	`15`
`16`	`16`	`public void Open()`
`17`	`17`	`{`
`18`		`- FileManager.CurrentDir = ModLoader.ModLoader.PathMods;`
	`18`	`+ FileManager.CurrentDir = GameManager.ModLoader.PathMods;`
`19`	`19`	`FileManager.PopupCentered();`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -4,19 +4,19 @@`
`4`	`4`
`5`	`5`	`using System.IO;`
`6`	`6`
`7`		`-namespace GodotModules.ModLoader`
	`7`	`+namespace GodotModules`
`8`	`8`	`{`
`9`	`9`	`public class ModLoader`
`10`	`10`	`{`
`11`		`- public static List<Mod> LoadedMods = new List<Mod>();`
`12`		`- public static Dictionary<string, Mod> ModInfo = new Dictionary<string, Mod>();`
`13`		`- private static MoonSharpVsCodeDebugServer DebugServer { get; set; }`
`14`		`- public static string PathModsEnabled { get; set; }`
`15`		`- public static string PathMods { get; set; }`
`16`		`- public static Script Script { get; set; }`
`17`		`- public static string LuaScriptsPath = "";`
`18`		`-`
`19`		`- public static void Init()`
	`11`	`+ public List<Mod> LoadedMods = new List<Mod>();`
	`12`	`+ public Dictionary<string, Mod> ModInfo = new Dictionary<string, Mod>();`
	`13`	`+ private MoonSharpVsCodeDebugServer DebugServer { get; set; }`
	`14`	`+ public string PathModsEnabled { get; set; }`
	`15`	`+ public string PathMods { get; set; }`
	`16`	`+ public Script Script { get; set; }`
	`17`	`+ public string LuaScriptsPath = "";`
	`18`	`+`
	`19`	`+ public void Init()`
`20`	`20`	`{`
`21`	`21`	`PathMods = Path.Combine(GameManager.GetGameDataPath(), "Mods");`
`22`	`22`	`PathModsEnabled = Path.Combine(PathMods, "enabled.json");`
`@@ -33,7 +33,7 @@ public static void Init()`
`33`	`33`	`SortMods();`
`34`	`34`	`}`
`35`	`35`
`36`		`- public static void SortMods()`
	`36`	`+ public void SortMods()`
`37`	`37`	`{`
`38`	`38`	`LoadedMods.Clear();`
`39`	`39`	`ModInfo = FindAllMods();`
`@@ -57,7 +57,7 @@ public static void SortMods()`
`57`	`57`	`});`
`58`	`58`	`}`
`59`	`59`
`60`		`- public static void LoadMods()`
	`60`	`+ public void LoadMods()`
`61`	`61`	`{`
`62`	`62`	`UIModLoader.Instance.ClearLog();`
`63`	`63`
`@@ -83,7 +83,7 @@ public static void LoadMods()`
`83`	`83`	`UIModLoader.Instance.Log($"{modLoadedCount} mods have loaded successfully");`
`84`	`84`	`}`
`85`	`85`
`86`		`- private static void DisableModsWithLackingDependencies()`
	`86`	`+ private void DisableModsWithLackingDependencies()`
`87`	`87`	`{`
`88`	`88`	`var modsToDisable = new List<ModInfo>();`
`89`	`89`
`@@ -99,7 +99,7 @@ private static void DisableModsWithLackingDependencies()`
`99`	`99`	`mod.Enabled = false;`
`100`	`100`	`}`
`101`	`101`
`102`		`- private static void CheckAllDependenciesEnabled(ModInfo firstMod, ModInfo modInfo, List<string> checkedMods, ref List<ModInfo> modsToDisable)`
	`102`	`+ private void CheckAllDependenciesEnabled(ModInfo firstMod, ModInfo modInfo, List<string> checkedMods, ref List<ModInfo> modsToDisable)`
`103`	`103`	`{`
`104`	`104`	`foreach (var dependency in modInfo.Dependencies)`
`105`	`105`	`{`
`@@ -117,7 +117,7 @@ private static void CheckAllDependenciesEnabled(ModInfo firstMod, ModInfo modInf`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`120`		`- public static void Call(string v, params object[] args)`
	`120`	`+ public void Call(string v, params object[] args)`
`121`	`121`	`{`
`122`	`122`	`try`
`123`	`123`	`{`
`@@ -130,7 +130,7 @@ public static void Call(string v, params object[] args)`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`- public static void SetModsEnabled()`
	`133`	`+ public void SetModsEnabled()`
`134`	`134`	`{`
`135`	`135`	`var modsEnabled = new Dictionary<string, bool>();`
`136`	`136`	`foreach (var mod in ModInfo)`
`@@ -139,7 +139,7 @@ public static void SetModsEnabled()`
`139`	`139`	`File.WriteAllText(PathModsEnabled, JsonConvert.SerializeObject(modsEnabled, Formatting.Indented));`
`140`	`140`	`}`
`141`	`141`
`142`		`- public static void GetModsEnabled()`
	`142`	`+ public void GetModsEnabled()`
`143`	`143`	`{`
`144`	`144`	`if (!File.Exists(PathModsEnabled))`
`145`	`145`	`return;`
`@@ -152,13 +152,13 @@ public static void GetModsEnabled()`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`		`- private static void Log(object obj)`
	`155`	`+ private void Log(object obj)`
`156`	`156`	`{`
`157`	`157`	`Logger.Log($"[ModLoader]: {obj}");`
`158`	`158`	`UIModLoader.Instance.Log($"{obj}");`
`159`	`159`	`}`
`160`	`160`
`161`		`- private static void LoadLuaScripts(string directory)`
	`161`	`+ private void LoadLuaScripts(string directory)`
`162`	`162`	`{`
`163`	`163`	`GodotFileManager.LoadDir(directory, (dir, fileName) =>`
`164`	`164`	`{`
`@@ -182,15 +182,15 @@ private static void LoadLuaScripts(string directory)`
`182`	`182`	`});`
`183`	`183`	`}`
`184`	`184`
`185`		`- private static void SetupModsEnabled()`
	`185`	`+ private void SetupModsEnabled()`
`186`	`186`	`{`
`187`	`187`	`if (File.Exists(PathModsEnabled))`
`188`	`188`	`return;`
`189`	`189`
`190`	`190`	`File.WriteAllText(PathModsEnabled, "{}");`
`191`	`191`	`}`
`192`	`192`
`193`		`- private static Dictionary<string, Mod> FindAllMods()`
	`193`	`+ private Dictionary<string, Mod> FindAllMods()`
`194`	`194`	`{`
`195`	`195`	`var mods = new Dictionary<string, Mod>();`
`196`	`196`	`var modFolders = Directory.GetDirectories(PathMods);`
`@@ -233,13 +233,13 @@ private static Dictionary<string, Mod> FindAllMods()`
`233`	`233`	`return mods;`
`234`	`234`	`}`
`235`	`235`
`236`		`- private static void AddDependencyToLoadedMods(int modIndex, string dependency)`
	`236`	`+ private void AddDependencyToLoadedMods(int modIndex, string dependency)`
`237`	`237`	`{`
`238`	`238`	`if (!LoadedMods.Contains(ModInfo[dependency]))`
`239`	`239`	`LoadedMods.Insert(modIndex, ModInfo[dependency]);`
`240`	`240`	`}`
`241`	`241`
`242`		`- private static void LoadMod(Mod mod, ref int modLoadedCount)`
	`242`	`+ private void LoadMod(Mod mod, ref int modLoadedCount)`
`243`	`243`	`{`
`244`	`244`	`try`
`245`	`245`	`{`
`@@ -255,15 +255,15 @@ private static void LoadMod(Mod mod, ref int modLoadedCount)`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`258`		`- private static bool ModHasName(ModInfo modInfo) => modInfo.Name != null;`
	`258`	`+ private bool ModHasName(ModInfo modInfo) => modInfo.Name != null;`
`259`	`259`
`260`		`- private static bool RequiredModFilesExist(string folder, string pathInfo, string pathScriptLua) => File.Exists(pathInfo) && File.Exists(pathScriptLua);`
	`260`	`+ private bool RequiredModFilesExist(string folder, string pathInfo, string pathScriptLua) => File.Exists(pathInfo) && File.Exists(pathScriptLua);`
`261`	`261`
`262`		`- private static bool IsModMissingDependency(string dependency) => !ModInfo.ContainsKey(dependency);`
	`262`	`+ private bool IsModMissingDependency(string dependency) => !ModInfo.ContainsKey(dependency);`
`263`	`263`
`264`		`- private static bool ModHasDependency(string dependency) => ModInfo.ContainsKey(dependency);`
	`264`	`+ private bool ModHasDependency(string dependency) => ModInfo.ContainsKey(dependency);`
`265`	`265`
`266`		`- private static bool ModHasAllDependenciesEnabled(Mod mod)`
	`266`	`+ private bool ModHasAllDependenciesEnabled(Mod mod)`
`267`	`267`	`{`
`268`	`268`	`var allDependenciesEnabled = true;`
`269`	`269`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using Godot;`
`2`	`2`
`3`		`-namespace GodotModules.ModLoader`
	`3`	`+namespace GodotModules`
`4`	`4`	`{`
`5`	`5`	`public class UIModInfo : Control`
`6`	`6`	`{`
`@@ -43,7 +43,7 @@ private void _on_Enabled_pressed()`
`43`	`43`	`var modName = BtnMod.Text;`
`44`	`44`
`45`	`45`	`BtnModEnabled.Text = Enabled ? "[x]" : "[ ]";`
`46`		`- ModLoader.ModInfo[modName].ModInfo.Enabled = Enabled;`
	`46`	`+ GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled = Enabled;`
`47`	`47`
`48`	`48`	`if (DisplayedInDependencies)`
`49`	`49`	`UIModLoader.Instance.ModInfoList[modName].SetModEnabled(Enabled);`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`using System;`
`3`	`3`	`using System.Diagnostics;`
`4`	`4`
`5`		`-namespace GodotModules.ModLoader`
	`5`	`+namespace GodotModules`
`6`	`6`	`{`
`7`	`7`	`public class UIModLoader : Control`
`8`	`8`	`{`
`@@ -31,7 +31,7 @@ public class UIModLoader : Control`
`31`	`31`	`// logger`
`32`	`32`	`private RichTextLabel Logger { get; set; }`
`33`	`33`
`34`		`- public override void _Ready()`
	`34`	`+ public override async void _Ready()`
`35`	`35`	`{`
`36`	`36`	`Instance = this;`
`37`	`37`	`ModList = GetNode<VBoxContainer>(NodePathModList);`
`@@ -46,8 +46,8 @@ public override void _Ready()`
`46`	`46`	`ModDescription.Text = "";`
`47`	`47`	`Logger.Clear();`
`48`	`48`
`49`		`- ModLoader.Init();`
`50`		`- ModLoader.LoadMods();`
	`49`	`+ while (GameManager.ModLoader == null) // this is ugly`
	`50`	`+ await Task.Delay(1);`
`51`	`51`
`52`	`52`	`DisplayMods();`
`53`	`53`	`}`
`@@ -61,7 +61,7 @@ public void UpdateModInfo(string name)`
`61`	`61`	`foreach (Node node in ModDependencies.GetChildren())`
`62`	`62`	`node.QueueFree();`
`63`	`63`
`64`		`- var modInfo = ModLoader.ModInfo[name].ModInfo;`
	`64`	`+ var modInfo = GameManager.ModLoader.ModInfo[name].ModInfo;`
`65`	`65`
`66`	`66`	`ModName.Text = name;`
`67`	`67`
`@@ -86,24 +86,24 @@ public void UpdateModInfo(string name)`
`86`	`86`
`87`	`87`	`public void DisplayMods()`
`88`	`88`	`{`
`89`		`- ModLoader.LoadedMods.ForEach(mod =>`
	`89`	`+ GameManager.ModLoader.LoadedMods.ForEach(mod =>`
`90`	`90`	`{`
`91`	`91`	`var modInfo = CreateModInfoInstance(mod.ModInfo.Name);`
`92`	`92`	`ModList.AddChild(modInfo);`
`93`	`93`	`ModInfoList[mod.ModInfo.Name] = modInfo;`
`94`	`94`	`});`
`95`	`95`
`96`		`- if (ModLoader.LoadedMods.Count > 0)`
`97`		`- UpdateModInfo(ModLoader.LoadedMods[0].ModInfo.Name);`
	`96`	`+ if (GameManager.ModLoader.LoadedMods.Count > 0)`
	`97`	`+ UpdateModInfo(GameManager.ModLoader.LoadedMods[0].ModInfo.Name);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`private UIModInfo CreateModInfoInstance(string modName)`
`101`	`101`	`{`
`102`	`102`	`var instance = Prefabs.ModInfo.Instance<UIModInfo>();`
`103`	`103`	`instance.SetModName(modName);`
`104`	`104`
`105`		`- if (ModLoader.ModInfo[modName].ModInfo.Enabled)`
`106`		`- instance.SetModEnabled(ModLoader.ModInfo[modName].ModInfo.Enabled);`
	`105`	`+ if (GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled)`
	`106`	`+ instance.SetModEnabled(GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled);`
`107`	`107`	`else`
`108`	`108`	`instance.SetModEnabled(false);`
`109`	`109`
`@@ -112,12 +112,12 @@ private UIModInfo CreateModInfoInstance(string modName)`
`112`	`112`
`113`	`113`	`private void _on_Refresh_pressed()`
`114`	`114`	`{`
`115`		`- ModLoader.SetModsEnabled();`
	`115`	`+ GameManager.ModLoader.SetModsEnabled();`
`116`	`116`
`117`	`117`	`foreach (Node node in ModList.GetChildren())`
`118`	`118`	`node.QueueFree();`
`119`	`119`
`120`		`- ModLoader.SortMods();`
	`120`	`+ GameManager.ModLoader.SortMods();`
`121`	`121`	`DisplayMods();`
`122`	`122`	`}`
`123`	`123`
`@@ -128,11 +128,11 @@ private void _on_Load_Mods_pressed()`
`128`	`128`	`var modName = info.ModName;`
`129`	`129`	`var modEnabled = info.Enabled;`
`130`	`130`
`131`		`- ModLoader.ModInfo[modName].ModInfo.Enabled = modEnabled;`
	`131`	`+ GameManager.ModLoader.ModInfo[modName].ModInfo.Enabled = modEnabled;`
`132`	`132`	`}`
`133`	`133`
`134`		`- ModLoader.SetModsEnabled();`
`135`		`- ModLoader.LoadMods();`
	`134`	`+ GameManager.ModLoader.SetModsEnabled();`
	`135`	`+ GameManager.ModLoader.LoadMods();`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`private void _on_Open_Mods_Folder_pressed()`
`@@ -145,7 +145,7 @@ private void _on_Open_Mods_Folder_pressed()`
`145`	`145`	`{`
`146`	`146`	`using (Process myProcess = new Process())`
`147`	`147`	`{`
`148`		`- myProcess.StartInfo.FileName = ModLoader.PathMods;`
	`148`	`+ myProcess.StartInfo.FileName = GameManager.ModLoader.PathMods;`
`149`	`149`	`myProcess.Start();`
`150`	`150`	`}`
`151`	`151`	`}`