Sync serialization refactor

Source/Client/Debug/DebugActions.cs

@@ -134,17 +134,18 @@ public static void SaveGame()
         public static void DumpSyncTypes()
         {
             var dict = new Dictionary<string, Type[]>() {
-                {"ThingComp", RwImplSerialization.thingCompTypes},
-                {"AbilityComp", RwImplSerialization.abilityCompTypes},
                 {"Designator", RwImplSerialization.designatorTypes},
-                {"WorldObjectComp", RwImplSerialization.worldObjectCompTypes},
-                {"HediffComp", RwImplSerialization.hediffCompTypes},
                 {"IStoreSettingsParent", RwImplSerialization.storageParents},
                 {"IPlantToGrowSettable", RwImplSerialization.plantToGrowSettables},
 
-                {"GameComponent", RwImplSerialization.gameCompTypes},
-                {"WorldComponent", RwImplSerialization.worldCompTypes},
-                {"MapComponent", RwImplSerialization.mapCompTypes},
+                {"ThingComp", CompSerialization.thingCompTypes},
+                {"AbilityComp", CompSerialization.abilityCompTypes},
+                {"WorldObjectComp", CompSerialization.worldObjectCompTypes},
+                {"HediffComp", CompSerialization.hediffCompTypes},
+
+                {"GameComponent", CompSerialization.gameCompTypes},
+                {"WorldComponent", CompSerialization.worldCompTypes},
+                {"MapComponent", CompSerialization.mapCompTypes},
             };
 
             foreach(var kv in dict) {

Source/Client/EarlyInit.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using HarmonyLib;
 using Multiplayer.Client.Patches;
@@ -55,10 +56,12 @@ internal static void EarlyPatches(Harmony harmony)
 
     internal static void InitSync()
     {
-        using (DeepProfilerWrapper.Section("Multiplayer SyncSerialization.Init"))
-            SyncSerialization.Init();
+        MpReflection.allAssembliesHook = RwAllAssemblies;
 
-        using (DeepProfilerWrapper.Section("Multiplayer SyncGame"))
+        using (DeepProfilerWrapper.Section("Multiplayer RwSerialization.Init"))
+            RwSerialization.Init();
+
+        using (DeepProfilerWrapper.Section("Multiplayer SyncGame.Init"))
             SyncGame.Init();
 
         using (DeepProfilerWrapper.Section("Multiplayer Sync register attributes"))
@@ -68,6 +71,18 @@ internal static void InitSync()
             Sync.ValidateAll();
     }
 
+    private static IEnumerable<Assembly> RwAllAssemblies()
+    {
+        yield return Assembly.GetAssembly(typeof(Game));
+
+        foreach (ModContentPack mod in LoadedModManager.RunningMods)
+            foreach (Assembly assembly in mod.assemblies.loadedAssemblies)
+                yield return assembly;
+
+        if (Assembly.GetEntryAssembly() != null)
+            yield return Assembly.GetEntryAssembly();
+    }
+
     internal static void LatePatches()
     {
         if (MpVersion.IsDebug)

Source/Client/Multiplayer.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net472</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>11</LangVersion>
+    <LangVersion>12</LangVersion>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <OutputPath>bin</OutputPath>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>

Source/Client/MultiplayerData.cs

@@ -120,20 +120,20 @@ internal static void CollectDefInfos()
 
             int TypeHash(Type type) => GenText.StableStringHash(type.FullName);
 
-            dict["ThingComp"] = GetDefInfo(RwImplSerialization.thingCompTypes, TypeHash);
-            dict["AbilityComp"] = GetDefInfo(RwImplSerialization.abilityCompTypes, TypeHash);
-            dict["Designator"] = GetDefInfo(RwImplSerialization.designatorTypes, TypeHash);
-            dict["WorldObjectComp"] = GetDefInfo(RwImplSerialization.worldObjectCompTypes, TypeHash);
-            dict["HediffComp"] = GetDefInfo(RwImplSerialization.hediffCompTypes, TypeHash);
+            dict["ThingComp"] = GetDefInfo(CompSerialization.thingCompTypes, TypeHash);
+            dict["AbilityComp"] = GetDefInfo(CompSerialization.abilityCompTypes, TypeHash);
+            dict["WorldObjectComp"] = GetDefInfo(CompSerialization.worldObjectCompTypes, TypeHash);
+            dict["HediffComp"] = GetDefInfo(CompSerialization.hediffCompTypes, TypeHash);
             dict["IStoreSettingsParent"] = GetDefInfo(RwImplSerialization.storageParents, TypeHash);
             dict["IPlantToGrowSettable"] = GetDefInfo(RwImplSerialization.plantToGrowSettables, TypeHash);
+            dict["Designator"] = GetDefInfo(RwImplSerialization.designatorTypes, TypeHash);
             dict["DefTypes"] = GetDefInfo(DefSerialization.DefTypes, TypeHash);
 
-            dict["GameComponent"] = GetDefInfo(RwImplSerialization.gameCompTypes, TypeHash);
-            dict["WorldComponent"] = GetDefInfo(RwImplSerialization.worldCompTypes, TypeHash);
-            dict["MapComponent"] = GetDefInfo(RwImplSerialization.mapCompTypes, TypeHash);
-            dict["ISyncSimple"] = GetDefInfo(ImplSerialization.syncSimples, TypeHash);
-            dict["ISession"] = GetDefInfo(ImplSerialization.sessions, TypeHash);
+            dict["GameComponent"] = GetDefInfo(CompSerialization.gameCompTypes, TypeHash);
+            dict["WorldComponent"] = GetDefInfo(CompSerialization.worldCompTypes, TypeHash);
+            dict["MapComponent"] = GetDefInfo(CompSerialization.mapCompTypes, TypeHash);
+            dict["ISyncSimple"] = GetDefInfo(ApiSerialization.syncSimples, TypeHash);
+            dict["ISession"] = GetDefInfo(ApiSerialization.sessions, TypeHash);
 
             dict["PawnBio"] = GetDefInfo(SolidBioDatabase.allBios, b => b.name.GetHashCode());
 

Source/Client/Persistent/RitualData.cs

@@ -28,9 +28,9 @@ public void Sync(SyncWorker sync)
             sync.Bind(ref extraInfos);
 
             if (sync is WritingSyncWorker writer1)
-                DelegateSerialization.WriteDelegate(writer1.writer, action);
+                DelegateSerialization.WriteDelegate(writer1.Writer, action);
             else if (sync is ReadingSyncWorker reader)
-                action = (ActionCallback)DelegateSerialization.ReadDelegate(reader.reader);
+                action = (ActionCallback)DelegateSerialization.ReadDelegate(reader.Reader);
 
             sync.Bind(ref ritualLabel);
             sync.Bind(ref confirmText);

Source/Client/Persistent/SessionManager.cs

@@ -156,7 +156,7 @@ public void WriteSessionData(ByteWriter data)
 
         foreach (var session in semiPersistentSessions)
         {
-            data.WriteUShort((ushort)ImplSerialization.sessions.FindIndex(session.GetType()));
+            data.WriteUShort((ushort)ApiSerialization.sessions.FindIndex(session.GetType()));
             data.WriteInt32(session.SessionId);
 
             try
@@ -181,13 +181,13 @@ public void ReadSessionData(ByteReader data)
             ushort typeIndex = data.ReadUShort();
             int sessionId = data.ReadInt32();
 
-            if (typeIndex >= ImplSerialization.sessions.Length)
+            if (typeIndex >= ApiSerialization.sessions.Length)
             {
-                Log.Error($"Received data for ISession type with index out of range: {typeIndex}, session types count: {ImplSerialization.sessions.Length}");
+                Log.Error($"Received data for ISession type with index out of range: {typeIndex}, session types count: {ApiSerialization.sessions.Length}");
                 continue;
             }
 
-            var objType = ImplSerialization.sessions[typeIndex];
+            var objType = ApiSerialization.sessions[typeIndex];
 
             try
             {

Source/Client/Syncing/ImplSerialization.cs → Source/Client/Syncing/ApiSerialization.cs

@@ -4,7 +4,7 @@
 
 namespace Multiplayer.Client;
 
-public static class ImplSerialization
+public static class ApiSerialization
 {
     public static Type[] syncSimples;
     public static Type[] sessions;

Source/Client/Syncing/CompSerialization.cs

@@ -0,0 +1,31 @@
+using System;
+using Multiplayer.Client.Util;
+using RimWorld;
+using RimWorld.Planet;
+using Verse;
+
+namespace Multiplayer.Client;
+
+public static class CompSerialization
+{
+    public static Type[] gameCompTypes;
+    public static Type[] worldCompTypes;
+    public static Type[] mapCompTypes;
+
+    public static Type[] thingCompTypes;
+    public static Type[] hediffCompTypes;
+    public static Type[] abilityCompTypes;
+    public static Type[] worldObjectCompTypes;
+
+    public static void Init()
+    {
+        thingCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(ThingComp));
+        hediffCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(HediffComp));
+        abilityCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(AbilityComp));
+        worldObjectCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(WorldObjectComp));
+
+        gameCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(GameComponent));
+        worldCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(WorldComponent));
+        mapCompTypes = TypeUtil.AllSubclassesNonAbstractOrdered(typeof(MapComponent));
+    }
+}

Source/Client/Syncing/Dict/SyncDict.cs

@@ -1,17 +1,18 @@
-namespace Multiplayer.Client
+namespace Multiplayer.Client;
+
+public static class SyncDict
 {
-    public static class SyncDict
+    internal static SyncWorkerDictionaryTree syncWorkers;
+
+    public static void Init()
     {
-        internal static SyncWorkerDictionaryTree syncWorkers;
+        syncWorkers = SyncWorkerDictionaryTree.Merge(
+            SyncDictMisc.syncWorkers,
+            SyncDictRimWorld.syncWorkers,
+            SyncDictDlc.syncWorkers,
+            SyncDictMultiplayer.syncWorkers
+        );
 
-        public static void Init()
-        {
-            syncWorkers = SyncWorkerDictionaryTree.Merge(
-                SyncDictMisc.syncWorkers,
-                SyncDictRimWorld.syncWorkers,
-                SyncDictDlc.syncWorkers,
-                SyncDictMultiplayer.syncWorkers
-            );
-        }
+        SyncSerialization.syncTree = syncWorkers;
     }
 }

Source/Client/Syncing/Dict/SyncDictDlc.cs

@@ -13,7 +13,7 @@ namespace Multiplayer.Client
 {
     public static class SyncDictDlc
     {
-		internal static SyncWorkerDictionaryTree syncWorkers = new SyncWorkerDictionaryTree()
+		internal static SyncWorkerDictionaryTree syncWorkers = new()
         {
             #region Royalty
             {

Source/Client/Syncing/Dict/SyncDictMisc.cs

@@ -114,6 +114,48 @@ public static class SyncDictMisc
                 }
             },
             #endregion
+
+            #region Structs
+            {
+                (ByteWriter data, Rot4 rot) => data.WriteByte(rot.AsByte),
+                (ByteReader data) => new Rot4(data.ReadByte())
+            },
+            {
+                (ByteWriter data, IntVec3 vec) => {
+                    if (vec.y < 0) {
+                        data.WriteShort(-1);
+                    }
+                    else {
+                        data.WriteShort((short)vec.y);
+                        data.WriteShort((short)vec.x);
+                        data.WriteShort((short)vec.z);
+                    }
+                },
+                (ByteReader data) => {
+                    short y = data.ReadShort();
+                    if (y < 0)
+                        return IntVec3.Invalid;
+
+                    short x = data.ReadShort();
+                    short z = data.ReadShort();
+
+                    return new IntVec3(x, y, z);
+                }
+            },
+            {
+                (SyncWorker sync, ref Vector2 vec)  => {
+                    sync.Bind(ref vec.x);
+                    sync.Bind(ref vec.y);
+                }
+            },
+            {
+                (SyncWorker sync, ref Vector3 vec)  => {
+                    sync.Bind(ref vec.x);
+                    sync.Bind(ref vec.y);
+                    sync.Bind(ref vec.z);
+                }
+            },
+            #endregion
         };
     }
 }