feat(logging): enhance version logging with compatibility branch support

- Replaced direct version logging with a new method, `BuildVersionLogText`, to include compatibility branch information when applicable.
- Removed unused `RunHistoryMissingModelDbGetByIdPatch` registration from `PatcherSetup`.
- Refactored `RunHistoryMissingModelDbGetByIdTranspilerPatch` to streamline the transpilation process for missing model fallbacks, improving clarity and maintainability.

Author: BAKAOLC

Lifecycle/Patches/RunHistoryMissingModelDbGetByIdTranspilerPatch.cs

@@ -1,3 +1,6 @@
+using System.Reflection;
+using System.Reflection.Emit;
+using HarmonyLib;
 using MegaCrit.Sts2.Core.Models;
 using MegaCrit.Sts2.Core.Nodes.Screens.RunHistoryScreen;
 using MegaCrit.Sts2.Core.Rooms;
@@ -7,35 +10,26 @@
 
 namespace STS2RitsuLib.Lifecycle.Patches
 {
-    internal static class RunHistoryMissingModelScope
-    {
-        [ThreadStatic] private static int _depth;
-
-        internal static bool IsActive => _depth > 0;
-
-        internal static void Enter()
-        {
-            _depth++;
-        }
-
-        internal static void Exit()
-        {
-            if (_depth > 0)
-                _depth--;
-        }
-    }
-
     /// <summary>
-    ///     Creates an execution scope for run-history UI methods that may read missing mod models.
+    ///     Replaces <c>ModelDb.GetById&lt;CharacterModel&gt;</c> and <c>GetById&lt;ActModel&gt;</c> in run-history UI with
+    ///     <see cref="RunHistoryMissingModelSupport" /> so missing mod content does not throw.
     /// </summary>
     public class RunHistoryMissingModelDbGetByIdTranspilerPatch : IPatchMethod
     {
+        private static readonly MethodInfo CharacterFallback =
+            AccessTools.DeclaredMethod(typeof(RunHistoryMissingModelSupport),
+                nameof(RunHistoryMissingModelSupport.CharacterForRunHistory));
+
+        private static readonly MethodInfo ActFallback =
+            AccessTools.DeclaredMethod(typeof(RunHistoryMissingModelSupport),
+                nameof(RunHistoryMissingModelSupport.ActForRunHistory));
+
         /// <inheritdoc />
         public static string PatchId => "run_history_missing_model_db_getbyid_transpile";
 
         /// <inheritdoc />
         public static string Description =>
-            "Create run-history scope for missing-model fallbacks";
+            "Transpile run-history methods to use Character/Act fallbacks when ModelDb has no entry";
 
         /// <inheritdoc />
         public static bool IsCritical => false;
@@ -58,61 +52,41 @@ public static ModPatchTarget[] GetTargets()
         }
 
         /// <summary>
-        ///     Enters run-history missing-model support scope.
-        /// </summary>
-        public static void Prefix()
-        {
-            RunHistoryMissingModelScope.Enter();
-        }
-
-        /// <summary>
-        ///     Exits run-history scope even if the target method throws.
+        ///     Harmony transpiler: redirect ModelDb lookups to RitsuLib fallbacks.
         /// </summary>
-        public static void Finalizer()
+        public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
         {
-            RunHistoryMissingModelScope.Exit();
-        }
-    }
-
-    /// <summary>
-    ///     Uses run-history-specific fallbacks for missing character/act lookups.
-    /// </summary>
-    public class RunHistoryMissingModelDbGetByIdPatch : IPatchMethod
-    {
-        /// <inheritdoc />
-        public static string PatchId => "run_history_missing_model_db_getbyid";
-
-        /// <inheritdoc />
-        public static string Description =>
-            "Use Character/Act fallbacks in run-history scope when ModelDb.GetById has no entry";
-
-        /// <inheritdoc />
-        public static bool IsCritical => false;
-
-        /// <inheritdoc />
-        public static ModPatchTarget[] GetTargets()
-        {
-            return [new(typeof(ModelDb), nameof(ModelDb.GetById), [typeof(ModelId)])];
+            foreach (var code in instructions)
+            {
+                if (code.operand is MethodInfo called)
+                {
+                    if (IsModelDbGetByIdFor(called, typeof(CharacterModel)))
+                    {
+                        code.opcode = OpCodes.Call;
+                        code.operand = CharacterFallback;
+                    }
+                    else if (IsModelDbGetByIdFor(called, typeof(ActModel)))
+                    {
+                        code.opcode = OpCodes.Call;
+                        code.operand = ActFallback;
+                    }
+                }
+
+                yield return code;
+            }
         }
 
-        /// <summary>
-        ///     Replaces vanilla GetById throws with run-history fallback models.
-        /// </summary>
-        // ReSharper disable once InconsistentNaming
-        public static bool Prefix<T>(ModelId id, ref T __result) where T : AbstractModel
+        private static bool IsModelDbGetByIdFor(MethodInfo mi, Type typeArg)
         {
-            if (!RunHistoryMissingModelScope.IsActive)
-                return true;
+            if (!mi.IsGenericMethod || mi.DeclaringType != typeof(ModelDb))
+                return false;
 
-            if (typeof(T) == typeof(CharacterModel))
-            {
-                __result = (T)(AbstractModel)RunHistoryMissingModelSupport.CharacterForRunHistory(id);
+            var def = mi.GetGenericMethodDefinition();
+            if (def.Name != nameof(ModelDb.GetById))
                 return false;
-            }
 
-            if (typeof(T) != typeof(ActModel)) return true;
-            __result = (T)(AbstractModel)RunHistoryMissingModelSupport.ActForRunHistory(id);
-            return false;
+            var args = mi.GetGenericArguments();
+            return args.Length == 1 && args[0] == typeArg;
         }
     }
 }

RitsuLibFramework.PatcherSetup.cs

@@ -83,7 +83,6 @@ private static void RegisterLifecyclePatches()
             patcher.RegisterPatch<NContinueRunInfoShowInfoModelNotFoundPatch>();
             patcher.RegisterPatch<NRunHistoryRefreshAndSelectRunSuppressRethrowPatch>();
             patcher.RegisterPatch<RunHistoryMissingModelDbGetByIdTranspilerPatch>();
-            patcher.RegisterPatch<RunHistoryMissingModelDbGetByIdPatch>();
             patcher.RegisterPatch<NMultiplayerLoadGameScreenBeginRunMissingCharacterPatch>();
             patcher.RegisterPatch<NMultiplayerTestCharacterPaginatorAllCharactersPatch>();
             patcher.RegisterPatch<NCustomRunLoadScreenBeginRunMissingCharacterPatch>();

RitsuLibFramework.cs

@@ -166,7 +166,7 @@ public static void Initialize()
 
                 Logger.Info($"Framework ID: {Const.ModId}");
                 Logger.Info($"Framework Name: {Const.Name}");
-                Logger.Info($"Version: {Const.Version}");
+                Logger.Info(BuildVersionLogText());
                 Logger.Info("Initializing shared framework...");
                 ModTypeDiscoveryHub.EnsureBuiltInContributorsRegistered();
                 RitsuLibSettingsStore.Initialize();
@@ -219,6 +219,24 @@ public static void Initialize()
             }
         }
 
+        private static string BuildVersionLogText()
+        {
+            var compatBranchLabel = GetCompatBranchLabel();
+            if (string.IsNullOrWhiteSpace(compatBranchLabel))
+                return $"Version: {Const.Version}";
+
+            return $"Version: {Const.Version} [兼容分支: {compatBranchLabel}]";
+        }
+
+        private static string? GetCompatBranchLabel()
+        {
+#if STS2_V_0_103_2
+            return "0.103.2";
+#else
+            return null;
+#endif
+        }
+
         /// <summary>
         ///     Ensures profile-bound services (<c>ProfileManager</c>, profile-scoped <c>ModDataStore</c>) are initialized once.
         /// </summary>