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.

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,6 +1,8 @@
+using BepInEx.Configuration;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Unity.Netcode;
 using UnityEngine;
 using LogLevel = BepInEx.Logging.LogLevel;
@@ -36,7 +38,9 @@ public bool SyncEnabled
     }
 
     private readonly NetworkVariable<bool> _syncEnabled = new();
-    private NetworkList<SyncedEntryDelta> _deltas = null!;
+    private readonly NetworkList<SyncedEntryDelta> _deltas = new();
+    private readonly List<(ConfigFile, EventHandler<SettingChangedEventArgs>)> _settingChangedListeners = new();
+    private readonly List<(SyncedEntryBase, EventHandler)> _entrySyncEnabledChangedListeners = new();
 
     [MemberNotNull(nameof(EntryContainer))]
     private void EnsureEntryContainer()
@@ -48,7 +52,6 @@ private void EnsureEntryContainer()
     private void Awake()
     {
         EnsureEntryContainer();
-        _deltas = new NetworkList<SyncedEntryDelta>();
     }
 
     public override void OnNetworkSpawn()
@@ -59,28 +62,32 @@ public override void OnNetworkSpawn()
         {
             _syncEnabled.Value = true;
 
+            var index = 0;
             foreach (var syncedEntryBase in EntryContainer.Values)
             {
-                var currentIndex = _deltas.Count;
                 _deltas.Add(syncedEntryBase.ToDelta());
 
-                syncedEntryBase.BoxedEntry.ConfigFile.SettingChanged += (_, args) =>
+                void onSettingChanged(object sender, SettingChangedEventArgs args)
                 {
                     if (!ReferenceEquals(syncedEntryBase.BoxedEntry, args.ChangedSetting)) return;
-                    _deltas[currentIndex] = syncedEntryBase.ToDelta();
-                };
+                    _deltas[index] = syncedEntryBase.ToDelta();
+                }
+                var configFile = syncedEntryBase.BoxedEntry.ConfigFile;
+                configFile.SettingChanged += onSettingChanged;
+                _settingChangedListeners.Add((configFile, onSettingChanged));
 
-                syncedEntryBase.SyncEnabledChanged += (_, args) =>
+                void onEntrySyncEnabledChanged(object sender, EventArgs args)
                 {
-                    _deltas[currentIndex] = syncedEntryBase.ToDelta();
-                };
+                    _deltas[index] = syncedEntryBase.ToDelta();
+                }
+                syncedEntryBase.SyncEnabledChanged += onEntrySyncEnabledChanged;
+                _entrySyncEnabledChangedListeners.Add((syncedEntryBase, onEntrySyncEnabledChanged));
+                index++;
             }
 
             InitialSyncCompletedHandler?.Invoke(this, EventArgs.Empty);
-            return;
         }
-
-        if (IsClient)
+        else if (IsClient)
         {
             _syncEnabled.OnValueChanged += OnSyncEnabledChanged;
             _deltas.OnListChanged += OnClientDeltaListChanged;
@@ -94,6 +101,48 @@ public override void OnNetworkSpawn()
 
             InitialSyncCompletedHandler?.Invoke(this, EventArgs.Empty);
         }
+
+        base.OnNetworkSpawn();
+    }
+
+    public override void OnNetworkDespawn()
+    {
+        EnsureEntryContainer();
+
+        if (IsServer)
+        {
+            foreach (var (configFile, onSettingChanged) in _settingChangedListeners)
+            {
+                configFile.SettingChanged -= onSettingChanged;
+            }
+
+            foreach (var (syncedEntryBase, onEntrySyncEnabledChanged) in _entrySyncEnabledChangedListeners)
+            {
+                syncedEntryBase.SyncEnabledChanged -= onEntrySyncEnabledChanged;
+            }
+
+            _settingChangedListeners.Clear();
+            _entrySyncEnabledChangedListeners.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
+            // 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()