Sane rewrite

.config/dotnet-tools.json

@@ -7,6 +7,12 @@
       "commands": [
         "tcli"
       ]
+    },
+    "evaisa.netcodepatcher.cli": {
+      "version": "4.2.0",
+      "commands": [
+        "netcode-patch"
+      ]
     }
   }
 }

CSync/CSync.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
-        <TargetFrameworks>netstandard2.1;net472;net48</TargetFrameworks>
+        <TargetFramework>netstandard2.1</TargetFramework>
         <AssemblyName>com.sigurd.csync</AssemblyName>
         <Description>Configuration file syncing library for BepInEx.</Description>
         <RestoreAdditionalProjectSources>
@@ -43,10 +43,12 @@
     <ItemGroup>
         <ThunderstoreBuildCopyPath Include="$(TargetPath)" Destination="BepInEx/plugins/$(ProjectName)/"/>
     </ItemGroup>
-    
+
     <ItemGroup>
         <PackageReference Include="BepInEx.Analyzers" Version="1.*" PrivateAssets="all"/>
         <PackageReference Include="BepInEx.PluginInfoProps" Version="2.*" PrivateAssets="all"/>
+        <PackageReference Include="BepInEx.AssemblyPublicizer.MSBuild" Version="0.4.2" PrivateAssets="all"/>
+        <PackageReference Include="PolySharp" Version="1.14.1" PrivateAssets="all"/>
     </ItemGroup>
 
     <ItemGroup>
@@ -55,18 +57,18 @@
     </ItemGroup>
 
     <ItemGroup Condition="'$(CI)' != 'true'">
-        <Reference Include="Assembly-CSharp">
+        <Reference Include="Assembly-CSharp" Publicize="true">
             <HintPath>$(LethalCompanyDir)Lethal Company_Data\Managed\Assembly-CSharp.dll</HintPath>
         </Reference>
         <Reference Include="Unity.Collections">
             <HintPath>$(LethalCompanyDir)Lethal Company_Data\Managed\Unity.Collections.dll</HintPath>
         </Reference>
-        <Reference Include="Unity.Netcode.Runtime">
+        <Reference Include="Unity.Netcode.Runtime" Publicize="true">
             <HintPath>$(LethalCompanyDir)Lethal Company_Data\Managed\Unity.Netcode.Runtime.dll</HintPath>
         </Reference>
     </ItemGroup>
-    
-    <ItemGroup Condition="'$(CI)' == 'true'">
-        <PackageReference Include="LethalCompany.GameLibs.Steam" Version="49.0.0-alpha.1" />
+
+    <ItemGroup Condition="'$(CI)' == 'true' or $(UseGameLibs) == 'true'">
+        <PackageReference Include="LethalCompany.GameLibs.Steam" Publicize="true" Version="49.0.0-alpha.1" />
     </ItemGroup>
 </Project>

CSync/Extensions/ConfigDefinitionExtensions.cs

@@ -0,0 +1,12 @@
+using BepInEx.Configuration;
+using CSync.Lib;
+
+namespace CSync.Extensions;
+
+internal static class ConfigDefinitionExtensions
+{
+    public static SyncedConfigDefinition ToSynced(this ConfigDefinition definition)
+    {
+        return new(definition.Section, definition.Key);
+    }
+}

CSync/Extensions/ConfigEntryExtensions.cs

@@ -0,0 +1,13 @@
+using BepInEx.Configuration;
+using CSync.Lib;
+
+namespace CSync.Extensions;
+
+internal static class ConfigEntryExtensions
+{
+    public static (string ConfigFileRelativePath, SyncedConfigDefinition Definition) ToSyncedEntryIdentifier(
+        this ConfigEntryBase entry)
+    {
+        return (entry.ConfigFile.GetConfigFileRelativePath(), entry.Definition.ToSynced());
+    }
+}

CSync/Extensions/ConfigFileExtensions.cs

@@ -0,0 +1,13 @@
+using System.IO;
+using BepInEx;
+using BepInEx.Configuration;
+
+namespace CSync.Extensions;
+
+internal static class ConfigFileExtensions
+{
+    public static string GetConfigFileRelativePath(this ConfigFile configFile)
+    {
+        return Path.GetRelativePath(Paths.BepInExRootPath, configFile.ConfigFilePath);
+    }
+}

CSync/Extensions/SyncedBindingExtensions.cs

@@ -0,0 +1,63 @@
+using BepInEx.Configuration;
+using CSync.Lib;
+
+namespace CSync.Extensions;
+
+/// <summary>
+/// Contains helpful extension methods to aid with synchronization and reduce code duplication.
+/// </summary>
+public static class SyncedBindingExtensions {
+    /// <summary>
+    /// Binds an entry to this file and returns the converted synced entry.
+    /// </summary>
+    /// <param name="configFile">The currently selected config file.</param>
+    /// <param name="section">The category that this entry should show under.</param>
+    /// <param name="key">The name/identifier of this entry.</param>
+    /// <param name="defaultVal">The value assigned to this entry if not changed.</param>
+    /// <param name="description">The description indicating what this entry does.</param>
+    public static SyncedEntry<T> BindSyncedEntry<T>(
+        this ConfigFile configFile,
+        string section,
+        string key,
+        T defaultVal,
+        string description
+    ) {
+        return configFile.BindSyncedEntry(new ConfigDefinition(section, key), defaultVal, new ConfigDescription(description));
+    }
+
+    public static SyncedEntry<T> BindSyncedEntry<T>(
+        this ConfigFile configFile,
+        string section,
+        string key,
+        T defaultValue,
+        ConfigDescription? desc = null
+    ) {
+        return configFile.BindSyncedEntry(new ConfigDefinition(section, key), defaultValue, desc);
+    }
+
+    public static SyncedEntry<T> BindSyncedEntry<T>(
+        this ConfigFile configFile,
+        ConfigDefinition definition,
+        T defaultValue,
+        string description
+    ) {
+        return configFile.BindSyncedEntry(definition, defaultValue, new ConfigDescription(description));
+    }
+
+    public static SyncedEntry<T> BindSyncedEntry<T>(
+        this ConfigFile configFile,
+        ConfigDefinition definition,
+        T defaultValue,
+        ConfigDescription? description = null
+    ) {
+        ConfigManager.AddToFileCache(configFile);
+        return configFile.Bind(definition, defaultValue, description).ToSyncedEntry();
+    }
+
+    /// <summary>
+    /// Converts this entry into a serializable alternative, allowing it to be synced.
+    /// </summary>
+    public static SyncedEntry<T> ToSyncedEntry<T>(this ConfigEntry<T> entry) {
+        return new SyncedEntry<T>(entry);
+    }
+}

CSync/Lib/ConfigManager.cs

@@ -1,56 +1,106 @@
+using System;
 using BepInEx.Configuration;
 using BepInEx;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
-using HarmonyLib;
+using System.Security.Cryptography;
+using System.Text;
+using CSync.Extensions;
+using JetBrains.Annotations;
+using Unity.Netcode;
+using UnityEngine;
 
 namespace CSync.Lib;
 
 /// <summary>
 /// Helper class enabling the user to easily setup CSync.<br></br>
 /// Handles config registration, instance syncing and caching of BepInEx files.<br></br>
 /// </summary>
+[PublicAPI]
 public class ConfigManager {
-    internal static Dictionary<string, ConfigFile> FileCache = [];
-    internal static Dictionary<string, ISynchronizable> Instances = [];
+    internal static readonly Dictionary<string, ConfigFile> FileCache = [];
+    internal static readonly Dictionary<InstanceKey, ISyncedConfig> Instances = [];
 
-    internal static ConfigFile GetConfigFile(string fileName) {
-        bool exists = FileCache.TryGetValue(fileName, out ConfigFile cfg);
-        if (!exists) {
-            string absPath = Path.Combine(Paths.ConfigPath, fileName);
+    private static event Action? OnPopulateEntriesRequested;
+    internal static void PopulateEntries() => OnPopulateEntriesRequested?.Invoke();
 
-            cfg = new(absPath, false);
-            FileCache.Add(fileName, cfg);
-        }
+    private static readonly Lazy<GameObject> LazyPrefab;
+    internal static GameObject Prefab => LazyPrefab.Value;
+
+    static ConfigManager()
+    {
+        LazyPrefab = new Lazy<GameObject>(() =>
+        {
+            var container = new GameObject("CSyncPrefabContainer")
+            {
+                hideFlags = HideFlags.HideAndDontSave
+            };
+            container.SetActive(false);
+            UnityEngine.Object.DontDestroyOnLoad(container);
+
+            var prefab = new GameObject("ConfigSyncHolder");
+            prefab.transform.SetParent(container.transform);
+            var networkObject = prefab.AddComponent<NetworkObject>();
+            var hash = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes($"{MyPluginInfo.PLUGIN_GUID}:ConfigSyncHolder"));
+            networkObject.GlobalObjectIdHash = BitConverter.ToUInt32(hash);
+
+            return prefab;
+        });
+    }
+
+    internal static void AddToFileCache(ConfigFile configFile)
+    {
+        FileCache.TryAdd(configFile.GetConfigFileRelativePath(), configFile);
+    }
+
+    internal static ConfigFile GetConfigFile(string relativePath)
+    {
+        if (FileCache.TryGetValue(relativePath, out ConfigFile configFile))
+            return configFile;
 
-        return cfg;
+        string absolutePath = Path.GetFullPath(Path.Combine(Paths.BepInExRootPath, relativePath));
+        configFile = new(absolutePath, false);
+        FileCache.Add(relativePath, configFile);
+        return configFile;
     }
 
     /// <summary>
     /// Register a config with CSync, making it responsible for synchronization.<br></br>
     /// After calling this method, all clients will receive the host's config upon joining.
     /// </summary>
-    public static void Register<T>(T config) where T : SyncedConfig<T>, ISynchronizable {
-        string guid = config.GUID;
-
-        if (config == null) {
-            Plugin.Logger.LogError($"An error occurred registering config: {guid}\nConfig instance cannot be null!");
+    public static void Register<T>(T config) where T : SyncedConfig<T> {
+        if (config is null)
+        {
+            throw new ArgumentNullException(nameof(config), "Config instance is null, cannot register.");
         }
 
-        if (Instances.ContainsKey(guid)) {
-            Plugin.Logger.LogWarning($"Attempted to register config `{guid}` after it has already been registered!");
-            return;
+        var assemblyQualifiedTypeName = typeof(T).AssemblyQualifiedName ?? throw new ArgumentException(nameof(config));
+        var key = new InstanceKey(config.GUID, assemblyQualifiedTypeName);
+
+        try {
+            Instances.Add(key, config);
         }
+        catch (ArgumentException exc) {
+            throw new InvalidOperationException($"Attempted to register config instance of type `{typeof(T)}`, but an instance has already been registered.", exc);
+        }
+
+        SyncedInstance<T>.Instance = config;
+        OnPopulateEntriesRequested += config.PopulateEntryContainer;
 
-        config.InitInstance(config);
-        Instances.Add(guid, config);
+        var syncBehaviour = Prefab.AddComponent<ConfigSyncBehaviour>();
+        syncBehaviour.ConfigInstanceKey = key;
     }
 
-    internal static void SyncInstances() => Instances.Values.Do(i => i.SetupSync());
-    internal static void RevertSyncedInstances() => Instances.Values.Do(i => i.RevertSync());
-}
+    [UsedImplicitly]
+    [Serializable]
+    [SuppressMessage("ReSharper", "Unity.RedundantSerializeFieldAttribute")] // they are *not* redundant!
+    public readonly record struct InstanceKey(string Guid, string AssemblyQualifiedName)
+    {
+        [field: SerializeField]
+        public string Guid { get; }
 
-public interface ISynchronizable {
-    void SetupSync();
-    void RevertSync();
-}
+        [field: SerializeField]
+        public string AssemblyQualifiedName { get; }
+    }
+}