fix(Combat): refine power expiration logic in ModTemporaryPowerTemplate (Closes #48)

- Improved the expiration conditions for temporary powers based on the turn end of participants, ensuring accurate behavior during extra turns.
- Enhanced clarity by differentiating between owner participation and side checks, preventing premature expiration of powers for non-participating creatures.

Author: BAKAOLC

Compat/Sts2ModManagerCompat.cs

@@ -82,6 +82,15 @@ internal static IReadOnlyList<Sts2ModInventoryEntry> BuildModInventoryEntries()
                 .ToArray();
         }
 
+        internal static IReadOnlyList<Sts2ModInventoryEntry> BuildLoadedModInventoryEntries()
+        {
+            return EnumerateLoadedModsWithAssembly()
+                .Select(TryBuildModInventoryEntry)
+                .Where(entry => entry != null)
+                .Select(entry => entry!)
+                .ToArray();
+        }
+
         private static Sts2ModInventoryEntry? TryBuildModInventoryEntry(Mod mod)
         {
             try

Diagnostics/StartupModListLogger.cs

@@ -0,0 +1,114 @@
+using System.Text;
+using MegaCrit.Sts2.Core.Modding;
+using STS2RitsuLib.Compat;
+
+namespace STS2RitsuLib.Diagnostics
+{
+    internal static class StartupModListLogger
+    {
+        private const string Prefix = "[ModList]";
+        private static readonly Lock SyncRoot = new();
+        private static bool _initialized;
+        private static bool _logged;
+
+        internal static void Initialize()
+        {
+            lock (SyncRoot)
+            {
+                if (_initialized)
+                    return;
+
+                _initialized = true;
+            }
+
+            ModManager.OnModDetected += OnModDetected;
+            TryLogAfterInitialModLoading();
+            RitsuLibFramework.SubscribeLifecycleOnce<MainMenuReadyEvent>(_ => TryLogStartupModList());
+        }
+
+        private static void OnModDetected(Mod _)
+        {
+            TryLogAfterInitialModLoading();
+        }
+
+        private static void TryLogAfterInitialModLoading()
+        {
+            IReadOnlyList<Sts2ModInventoryEntry> registeredMods;
+            try
+            {
+                registeredMods = Sts2ModManagerCompat.BuildModInventoryEntries();
+            }
+            catch (Exception ex)
+            {
+                RitsuLibFramework.Logger.Warn($"{Prefix} Failed to inspect mod loading state: {ex.Message}");
+                return;
+            }
+
+            if (registeredMods.Count == 0 ||
+                registeredMods.Any(static mod => string.Equals(mod.State, "None", StringComparison.Ordinal)))
+                return;
+
+            TryLogStartupModList();
+        }
+
+        private static void TryLogStartupModList()
+        {
+            lock (SyncRoot)
+            {
+                if (_logged)
+                    return;
+
+                _logged = true;
+            }
+
+            ModManager.OnModDetected -= OnModDetected;
+
+            try
+            {
+                var loadedMods = Sts2ModManagerCompat.BuildLoadedModInventoryEntries();
+                var registeredMods = Sts2ModManagerCompat.BuildModInventoryEntries();
+                var hostVersion = Sts2HostVersion.ReleaseLabel
+                                  ?? Sts2HostVersion.Numeric?.ToString()
+                                  ?? "unknown";
+
+                var text = new StringBuilder()
+                    .AppendLine()
+                    .AppendLine("=== RitsuLib Mod Debug Information ===")
+                    .AppendLine($"Host Version: {hostVersion}")
+                    .AppendLine($"RitsuLib {RitsuLibFramework.BuildVersionLogText()}")
+                    .AppendLine($"Loaded Mods: {loadedMods.Count}")
+                    .AppendLine($"Registered Mods: {registeredMods.Count}")
+                    .AppendLine("Mod List:");
+
+                if (loadedMods.Count == 0)
+                {
+                    text.AppendLine("  <none>");
+                    RitsuLibFramework.Logger.Info(text.ToString());
+                    return;
+                }
+
+                foreach (var mod in loadedMods)
+                    text.AppendLine($"  * {FormatModName(mod)} ({FormatVersion(mod)})");
+
+                RitsuLibFramework.Logger.Info(text.ToString());
+            }
+            catch (Exception ex)
+            {
+                RitsuLibFramework.Logger.Warn($"{Prefix} Failed to print startup mod list: {ex.Message}");
+            }
+        }
+
+        private static string FormatModName(Sts2ModInventoryEntry mod)
+        {
+            var name = string.IsNullOrWhiteSpace(mod.Name) ? mod.Id : mod.Name.Trim();
+            return string.Equals(name, mod.Id, StringComparison.Ordinal)
+                ? name
+                : $"{name} [{mod.Id}]";
+        }
+
+        private static string FormatVersion(Sts2ModInventoryEntry mod)
+        {
+            return string.IsNullOrWhiteSpace(mod.Version) ? "unknown version" : mod.Version.Trim();
+        }
+    }
+}

RitsuLibFramework.cs

@@ -314,6 +314,7 @@ public static void Initialize()
                 }
 
                 Logger = CreateLogger(Const.ModId);
+                StartupModListLogger.Initialize();
 
                 Logger.Info($"Framework ID: {Const.ModId}");
                 Logger.Info($"Framework Name: {Const.Name}");
@@ -387,12 +388,10 @@ public static void Initialize()
             }
         }
 
-        private static string BuildVersionLogText()
+        internal static string BuildVersionLogText()
         {
             var compatBranchLabel = GetCompatBranchLabel();
-            return string.IsNullOrWhiteSpace(compatBranchLabel)
-                ? $"Version: {Const.Version}"
-                : $"Version: {Const.Version} [compat branch: {compatBranchLabel}]";
+            return $"Version: {Const.Version} [compat branch: {compatBranchLabel}]";
         }
 
         private static void EnsureFrameworkInteropBootstrapRegistered()
@@ -413,14 +412,16 @@ private static void ConfirmExternalFrameworkInterop()
             MaxHandSizePatchInstaller.EnsurePatched();
         }
 
-        private static string? GetCompatBranchLabel()
+        private static string GetCompatBranchLabel()
         {
-#if !STS2_AT_LEAST_0_104_0
+#if STS2_AT_LEAST_0_106_1
+            return "0.106.1";
+#elif STS2_AT_LEAST_0_105_1
+            return "0.105.1";
+#elif STS2_AT_LEAST_0_103_2
             return "0.103.2";
-#elif !STS2_AT_LEAST_0_105_0
-            return "0.104.0";
 #else
-            return null;
+            return "unknown";
 #endif
         }