fix delegates lifetime: unsubscribe stale handlers on network despawn

CSync leaves stale change handlers after quitting the hosted game.

When the host quits the game back to the main menu, ConfigSyncBehaviour
despawns and gets destroyed by Unity (not by .NET GC), but any delegates
connected to events in OnNetworkSpawn method remain and go stale.

So next time a player hosts a lobby without shutting down and
re-launching the game completely, when any of subscribed config files
or config entries change, stale delegates execute and try to assign to
a dead NetworkList _deltas[index]. Of course it results in an exception
being logged to the console by BepInEx (which wraps event handler
invocation in a try-catch).

To fix this, store subscribed delegates, and properly unsubscribe them
during despawn.

Note that NetworkList and _syncEnabled variable can not be cleared/reset
due to Unity issue which only got resolved in the most recent version.
Lethal Company v73 updated Unity Netcode for GameObjects (NGO) to
1.12.0, but the fix is available for NGO 1.14.0+ only.

References:
- https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/using-delegates
- Unity-Technologies/com.unity.netcode.gameobjects#3502

Fixes lc-sigurd#13

Author: ratijas

CSync/CSync/Lib/ConfigSyncBehaviour.cs

@@ -1,3 +1,4 @@
+using BepInEx.Configuration;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -37,6 +38,7 @@ public bool SyncEnabled
 
     private readonly NetworkVariable<bool> _syncEnabled = new();
     private NetworkList<SyncedEntryDelta> _deltas = null!;
+    private readonly List<EventHandlerHelper> _eventHandlers = new();
 
     [MemberNotNull(nameof(EntryContainer))]
     private void EnsureEntryContainer()
@@ -51,6 +53,42 @@ private void Awake()
         _deltas = new NetworkList<SyncedEntryDelta>();
     }
 
+    // Helper class to maintain event subscriptions.
+    // SyncedEntryDelta is a struct which can't be copied around, so it has to be stored by list+index.
+    class EventHandlerHelper : IDisposable
+    {
+        private readonly NetworkList<SyncedEntryDelta> deltas;
+        private readonly int index;
+        private readonly SyncedEntryBase syncedEntryBase;
+
+        public EventHandlerHelper(NetworkList<SyncedEntryDelta> deltas, int index, SyncedEntryBase syncedEntryBase)
+        {
+            this.deltas = deltas;
+            this.index = index;
+            this.syncedEntryBase = syncedEntryBase;
+
+            syncedEntryBase.BoxedEntry.ConfigFile.SettingChanged += OnSettingChanged;
+            syncedEntryBase.SyncEnabledChanged += OnEntrySyncEnabledChanged;
+        }
+
+        public void Dispose()
+        {
+            syncedEntryBase.BoxedEntry.ConfigFile.SettingChanged -= OnSettingChanged;
+            syncedEntryBase.SyncEnabledChanged -= OnEntrySyncEnabledChanged;
+        }
+
+        void OnSettingChanged(object sender, SettingChangedEventArgs args)
+        {
+            if (!ReferenceEquals(syncedEntryBase.BoxedEntry, args.ChangedSetting)) return;
+            deltas[index] = syncedEntryBase.ToDelta();
+        }
+
+        void OnEntrySyncEnabledChanged(object sender, EventArgs args)
+        {
+            deltas[index] = syncedEntryBase.ToDelta();
+        }
+    }
+
     public override void OnNetworkSpawn()
     {
         base.OnNetworkSpawn();
@@ -65,17 +103,8 @@ public override void OnNetworkSpawn()
             {
                 var currentIndex = _deltas.Count;
                 _deltas.Add(syncedEntryBase.ToDelta());
-
-                syncedEntryBase.BoxedEntry.ConfigFile.SettingChanged += (_, args) =>
-                {
-                    if (!ReferenceEquals(syncedEntryBase.BoxedEntry, args.ChangedSetting)) return;
-                    _deltas[currentIndex] = syncedEntryBase.ToDelta();
-                };
-
-                syncedEntryBase.SyncEnabledChanged += (_, args) =>
-                {
-                    _deltas[currentIndex] = syncedEntryBase.ToDelta();
-                };
+                var eventHandlerHelper = new EventHandlerHelper(_deltas, currentIndex, syncedEntryBase);
+                _eventHandlers.Add(eventHandlerHelper);
             }
 
             InitialSyncCompletedHandler?.Invoke(this, EventArgs.Empty);
@@ -98,16 +127,44 @@ public override void OnNetworkSpawn()
 
     public override void OnNetworkDespawn()
     {
+        EnsureEntryContainer();
+
+        if (IsServer)
+        {
+            foreach (var eventHandlerHelper in _eventHandlers)
+            {
+                eventHandlerHelper.Dispose();
+            }
+
+            _eventHandlers.Clear();
+
+            // NetworkList and NetworkVariable can not be modified now because the network manager has already shut down.
+            // See https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/pull/3502
+            // The fix applies to NGO 1.14.0+, but Lethal Company v73 is on NGO 1.12.0
+            // Should not be needed anyway, since this component isn't being reused between network sessions.
+            // _deltas.Clear();
+            // _syncEnabled.Value = false;
+        }
+        else if (IsClient)
+        {
+            DisableOverrides();
+
+            foreach (var delta in _deltas)
+            {
+                ResetOverrideValue(delta);
+            }
+
+            _deltas.OnListChanged -= OnClientDeltaListChanged;
+            _syncEnabled.OnValueChanged -= OnSyncEnabledChanged;
+        }
+
         base.OnNetworkDespawn();
     }
 
     public override void OnDestroy()
     {
-        DisableOverrides();
-        foreach (var delta in _deltas)
-        {
-            ResetOverrideValue(delta);
-        }
+        // The content of this method has moved to OnNetworkDespawn.
+        // Keep this method around for ABI compatibility though.
         base.OnDestroy();
     }