feat(ReplayEvent): add serialization and deserialization for combat replay events

- Implemented ReplayEventSerialize and ReplayEventDeserialize patches to handle RitsuLib-managed actions within combat replay events.
- Updated RitsuLibManagedNetActions to allow actions to be recordable for replay by changing RecordableToReplay to true.
- Enhanced PatcherSetup to register the new serialization and deserialization patches, improving replay functionality.

Author: BAKAOLC

Networking/ManagedActions/Patches/RitsuLibManagedNetActionMessagePatches.cs

@@ -1,5 +1,7 @@
+using MegaCrit.Sts2.Core.Entities.Multiplayer;
 using MegaCrit.Sts2.Core.GameActions.Multiplayer;
 using MegaCrit.Sts2.Core.Multiplayer.Messages.Game;
+using MegaCrit.Sts2.Core.Multiplayer.Replay;
 using MegaCrit.Sts2.Core.Multiplayer.Serialization;
 using MegaCrit.Sts2.Core.Runs;
 using STS2RitsuLib.Patching.Models;
@@ -119,5 +121,108 @@ public static bool Prefix(ref ActionEnqueuedMessage __instance, PacketReader rea
                 return false;
             }
         }
+
+        internal sealed class ReplayEventSerialize : IPatchMethod
+        {
+            public static string PatchId => "ritsulib_managed_net_action_replay_event_serialize";
+            public static bool IsCritical => true;
+
+            public static string Description =>
+                "Serialize RitsuLib-managed actions inside combat replay events";
+
+            public static ModPatchTarget[] GetTargets()
+            {
+                return
+                [
+                    new(typeof(CombatReplayEvent),
+                        nameof(CombatReplayEvent.Serialize),
+                        [typeof(PacketWriter)]),
+                ];
+            }
+
+            // ReSharper disable once InconsistentNaming
+            public static bool Prefix(CombatReplayEvent __instance, PacketWriter writer)
+            {
+                writer.WriteInt((int)__instance.eventType, 3);
+                switch (__instance.eventType)
+                {
+                    case CombatReplayEventType.GameAction:
+                        writer.WriteULong(__instance.playerId!.Value);
+                        var action = __instance.action ??
+                                     throw new InvalidOperationException(
+                                         "Combat replay game action event has no action.");
+                        if (RitsuLibManagedNetActions.TryWriteNetAction(writer, action)) return false;
+                        writer.WriteByte((byte)action.ToId());
+                        writer.Write(action);
+                        break;
+                    case CombatReplayEventType.HookAction:
+                        writer.WriteULong(__instance.playerId!.Value);
+                        writer.WriteUInt(__instance.hookId!.Value);
+                        writer.WriteEnum(__instance.gameActionType!.Value);
+                        break;
+                    case CombatReplayEventType.ResumeAction:
+                        writer.WriteUInt(__instance.actionId!.Value);
+                        break;
+                    case CombatReplayEventType.PlayerChoice:
+                        writer.WriteULong(__instance.playerId!.Value);
+                        writer.WriteUInt(__instance.choiceId!.Value);
+                        writer.Write(__instance.playerChoiceResult!.Value);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(__instance.eventType));
+                }
+
+                return false;
+            }
+        }
+
+        internal sealed class ReplayEventDeserialize : IPatchMethod
+        {
+            public static string PatchId => "ritsulib_managed_net_action_replay_event_deserialize";
+            public static bool IsCritical => true;
+
+            public static string Description =>
+                "Deserialize RitsuLib-managed actions inside combat replay events";
+
+            public static ModPatchTarget[] GetTargets()
+            {
+                return
+                [
+                    new(typeof(CombatReplayEvent),
+                        nameof(CombatReplayEvent.Deserialize),
+                        [typeof(PacketReader)]),
+                ];
+            }
+
+            // ReSharper disable once InconsistentNaming
+            public static bool Prefix(ref CombatReplayEvent __instance, PacketReader reader)
+            {
+                __instance.eventType = (CombatReplayEventType)reader.ReadInt(3);
+                switch (__instance.eventType)
+                {
+                    case CombatReplayEventType.GameAction:
+                        __instance.playerId = reader.ReadULong();
+                        __instance.action = RitsuLibManagedNetActions.ReadNetAction(reader);
+                        break;
+                    case CombatReplayEventType.HookAction:
+                        __instance.playerId = reader.ReadULong();
+                        __instance.hookId = reader.ReadUInt();
+                        __instance.gameActionType = reader.ReadEnum<GameActionType>();
+                        break;
+                    case CombatReplayEventType.ResumeAction:
+                        __instance.actionId = reader.ReadUInt();
+                        break;
+                    case CombatReplayEventType.PlayerChoice:
+                        __instance.playerId = reader.ReadULong();
+                        __instance.choiceId = reader.ReadUInt();
+                        __instance.playerChoiceResult = reader.Read<NetPlayerChoiceResult>();
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+
+                return false;
+            }
+        }
     }
 }

Networking/ManagedActions/RitsuLibManagedNetActions.cs

@@ -380,7 +380,7 @@ public sealed class RitsuLibManagedGameAction(
         public override GameActionType ActionType { get; } = actionType;
 
         /// <inheritdoc />
-        public override bool RecordableToReplay => false;
+        public override bool RecordableToReplay => true;
 
         /// <inheritdoc />
         protected override async Task ExecuteAction()

RitsuLibFramework.PatcherSetup.cs

@@ -175,6 +175,8 @@ private static void RegisterLifecyclePatches()
             patcher.RegisterPatch<RitsuLibManagedNetActionMessagePatches.RequestDeserialize>();
             patcher.RegisterPatch<RitsuLibManagedNetActionMessagePatches.AnnouncementSerialize>();
             patcher.RegisterPatch<RitsuLibManagedNetActionMessagePatches.AnnouncementDeserialize>();
+            patcher.RegisterPatch<RitsuLibManagedNetActionMessagePatches.ReplayEventSerialize>();
+            patcher.RegisterPatch<RitsuLibManagedNetActionMessagePatches.ReplayEventDeserialize>();
             patcher.RegisterPatch<ModModelIdentityRunStateCreatePatch>();
             patcher.RegisterPatch<ModModelIdentityPlayerRunStatePatch>();
             patcher.RegisterPatch<ModModelIdentityRunStateAddCardPatch>();