Adding Modlist Tab to view all Loaded Mods

QModManager/API/IQModServices.cs

@@ -1,5 +1,6 @@
 namespace QModManager.API
 {
+    using System;
     using System.Reflection;
     using QModManager.Utility;
 
@@ -48,13 +49,28 @@ public interface IQModServices : IQModAPI
         /// </value>
         bool NitroxRunning { get; }
 
-
         /// <summary>
         /// Gets a value indicating whether Piracy was detected.
         /// </summary>
         /// <value>
         ///   <c>true</c> if Piracy was detected; otherwise, <c>false</c>.
         /// </value>
         bool PirateDetected { get; }
+
+        /// <summary>
+        /// Gets the current Q Mod Manager Version.
+        /// </summary>
+        /// <value>
+        ///   Return Running QMM Version.
+        /// </value>
+        Version QMMrunningVersion { get; }
+
+        /// <summary>
+        /// Gets a value indicating when a Savegame was already loaded. (Turns <c>true</c> when entering the Mainmenu again.)
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> Mainmenu is entered AFTER a Savegame was loaded already; otherwise, <c>false</c>.
+        /// </value>
+        bool AnySavegamewasalreadyloaded { get; }
     }
 }

QModManager/API/QModServices.cs

@@ -2,6 +2,7 @@
 
 namespace QModManager.API
 {
+    using System;
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
     using System.Reflection;
@@ -165,5 +166,21 @@ public void AddCriticalMessage(string msg, int size = MainMenuMessages.defaultSi
         ///   <c>true</c> if Piracy was detected; otherwise, <c>false</c>.
         /// </value>
         public bool PirateDetected => PirateCheck.PirateDetected;
+
+        /// <summary>
+        /// Gets the current Q Mod Manager Version.
+        /// </summary>
+        /// <value>
+        ///   Return Running QMM Version.
+        /// </value>
+        public Version QMMrunningVersion => Assembly.GetExecutingAssembly().GetName().Version;
+
+        /// <summary>
+        /// Gets a value indicating when a Savegame was already loaded (Turn true when entering the Mainmenu again.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> Mainmenu is entered AFTER a Savegame was loaded already; otherwise, <c>false</c>.
+        /// </value>
+        public bool AnySavegamewasalreadyloaded => ReturnfromSavegameWarning.AnySavegamewasloaded;
     }
 }

QModManager/Checks/PirateCheck.cs

@@ -7,13 +7,12 @@ namespace QModManager.Checks
 {
     internal static class PirateCheck
     {
-        internal static string Steamapi => "steam_api64.dll";
-        internal static int Steamapilengh => 220000;
-
-
-        internal static string folder = Environment.CurrentDirectory;
+        internal const string SteamApiName = "steam_api64.dll";
+        internal const int SteamApiLength = 220000;
         internal static bool PirateDetected;
 
+        private static readonly string _folder = Environment.CurrentDirectory;
+
         internal static readonly HashSet<string> CrackedFiles = new HashSet<string>()
         {
             "steam_api64.cdx",
@@ -26,18 +25,20 @@ internal static class PirateCheck
             "Subnautica_Data/Plugins/steam_emu.ini",
             "Profile/SteamUserID.cfg",
             "Profile/Stats/Achievements.Bin",
+            "Profile/VALVE/SteamUserID.cfg",
+            "Profile/VALVE/Stats/Achievements.Bin",
             "launcher.bat",
             "chuj.cdx",
         };
 
         internal static void IsPirate()
         {
-            string steamDll = Path.Combine(folder, Steamapi);
+            string steamDll = Path.Combine(_folder, SteamApiName);
             bool steamStore = File.Exists(steamDll);
             if (steamStore)
             {
                 FileInfo fileInfo = new FileInfo(steamDll);
-                if (fileInfo.Length > Steamapilengh)
+                if (fileInfo.Length > SteamApiLength)
                 {
                     PirateDetected = true;
                 }
@@ -47,15 +48,15 @@ internal static void IsPirate()
             {
                 foreach (string file in CrackedFiles)
                 {
-                    if (File.Exists(Path.Combine(folder, file)))
+                    if (File.Exists(Path.Combine(_folder, file)))
                     {
                         PirateDetected = true;
                         break;
                     }
                 }
             }
 
-            Logger.Info(PirateDetected? "Ahoy, matey! Ye be a pirate!":"Seems Legit.");
+            Logger.Info(PirateDetected ? "Ahoy, matey! Ye be a pirate!" : "Seems legit.");
         }
     }
 }

QModManager/Checks/VersionCheck.cs

@@ -19,13 +19,13 @@ internal static void Check()
         {
             if (!Config.CheckForUpdates)
             {
-                Logger.Info("Update check disabled");
+                Logger.Info("QMM Internal Versionchecker: Update check disabled");
                 return;
             }
 
             if (!NetworkUtilities.CheckConnection())
             {
-                Logger.Info("Cannot check for updates, internet disabled");
+                Logger.Info("QMM Internal Versionchecker: Cannot check for updates, internet disabled");
                 return;
             }
 
@@ -37,14 +37,14 @@ internal static void Check()
                 {
                     if (e.Error != null)
                     {
-                        Logger.Error("There was an error retrieving the latest version from GitHub!");
+                        Logger.Error("QMM Internal Versionchecker: There was an error retrieving the latest version from GitHub!");
                         Logger.Exception(e.Error);
                         return;
                     }
                     Parse(e.Result);
                 };
 
-                Logger.Debug("Getting the latest version...");
+                Logger.Debug("QMM Internal Versionchecker: Getting the latest version...");
                 client.DownloadStringAsync(new Uri(VersionURL));
             }
         }
@@ -56,32 +56,40 @@ internal static void Parse(string versionStr)
                 Version currentVersion = Assembly.GetExecutingAssembly().GetName().Version;
                 if (versionStr == null)
                 {
-                    Logger.Error("There was an error retrieving the latest version from GitHub!");
+                    Logger.Error("QMM Internal Versionchecker: There was an error retrieving the latest version from GitHub!");
                     return;
                 }
-                var latestVersion = new Version(versionStr);
+
+                string[] versionStr_splittet = versionStr.Split('.');
+                string version_builder = $"{versionStr_splittet[0]}.{(versionStr_splittet.Length >= 2 ? $"{versionStr_splittet[1]}" : "0")}.{(versionStr_splittet.Length >= 3 ? $"{versionStr_splittet[2]}" : "0")}.{(versionStr_splittet.Length >= 4 ? $"{versionStr_splittet[3]}" : "0")}";
+                var latestVersion = new Version(version_builder);
+
                 if (latestVersion == null)
                 {
-                    Logger.Error("There was an error retrieving the latest version from GitHub!");
+                    Logger.Error("QMM Internal Versionchecker: There was an error retrieving the latest version from GitHub!");
                     return;
                 }
+
+                //Logger.Debug($"QMM Version Checker - Parse - current Version value: {currentVersion}");
+                //Logger.Debug($"QMM Version Checker - Parse - latest Version value: {latestVersion}");
+
                 if (latestVersion > currentVersion)
                 {
                     Logger.Info($"Newer version found: {latestVersion.ToStringParsed()} (current version: {currentVersion.ToStringParsed()})");
                     result = latestVersion;
                 }
                 else if (latestVersion < currentVersion)
                 {
-                    Logger.Info($"Received latest version from GitHub. We're ahead. This is probably a development build.");
+                    Logger.Info($"QMM Internal Versionchecker: Received latest version ({latestVersion.ToStringParsed()}) from GitHub. We're ahead. This is probably a development build (current version: {currentVersion.ToStringParsed()}).");
                 }
                 else
                 {
-                    Logger.Info($"Received latest version from GitHub. We are up to date!");
+                    Logger.Info($"QMM Internal Versionchecker: Received latest version from GitHub. We are up to date!");
                 }
             }
             catch (Exception e)
             {
-                Logger.Error("There was an error retrieving the latest version from GitHub!");
+                Logger.Error("QMM Internal Versionchecker: There was an error retrieving the latest version from GitHub!");
                 Logger.Exception(e);
                 return;
             }

QModManager/HarmonyPatches/ReturnfromSavegameWarning.cs

@@ -0,0 +1,58 @@
+namespace QModManager.Patching
+{
+    using HarmonyLib;
+    using QModManager.API;
+    using MyLogger = Utility;
+    using UWE;
+    using System.Collections;
+    using UnityEngine;
+
+    internal static class ReturnfromSavegameWarning
+    {
+        public static bool AnySavegamewasloaded = false;
+    }
+
+    [HarmonyPatch(typeof(Player), nameof(Player.Awake))]
+    internal static class ReturnfromSavegameWarningPlayerAwake
+    {
+        [HarmonyPostfix]
+        internal static void Postfix(Player __instance)
+        {
+            if (ReturnfromSavegameWarning.AnySavegamewasloaded)
+            {
+                MyLogger.Logger.Error("Entering a Savegame after playing a other one without restarting the Game. Modders do not recommend that. Restart the Game to prevent errors or unexpected behaviour");
+                if (Utility.Config.ShowWarnOnLoadSecondSave)
+                {
+                    CoroutineHost.StartCoroutine(ShowIngameMessage_async("Modders do not recommend loading multiple savegames without restarting the game."));
+                }
+            }
+            else
+            {
+                ReturnfromSavegameWarning.AnySavegamewasloaded = true;
+            }
+        }
+        public static IEnumerator ShowIngameMessage_async(string Message)
+        {
+            yield return new WaitForSecondsRealtime(2);
+            yield return new WaitForSeconds(3);
+            ErrorMessage.AddMessage(Message);
+        }
+    }
+
+    [HarmonyPatch(typeof(uGUI_MainMenu), nameof(uGUI_MainMenu.Awake))]
+    internal static class ReturnfromSavegameWarninguGUI_MainMenuAwake
+    {
+        [HarmonyPostfix]
+        internal static void Postfix(uGUI_OptionsPanel __instance)
+        {
+            if (ReturnfromSavegameWarning.AnySavegamewasloaded)
+            {
+                MyLogger.Logger.Error("Entering Main Menu after playing a Savegame. Modders do not recommend to start or load a Savegame now. Restart the Game to prevent errors or unexpected behaviour");
+                if (Utility.Config.ShowWarnOnLoadSecondSave)
+                {
+                    //QModServices.Main.AddCriticalMessage("Note that Modders recommend to restart the Game before loading the next Savegame", 15, "orange");
+                }
+            }
+        }
+    }
+}