improve stability of script system

Author: Elektryk-Andrzej

Code/EventSystem/EventHandler.cs

@@ -27,6 +27,7 @@ public static class EventHandler
 
     public static void Initialize()
     {
+        Clear();
         AvailableEvents = typeof(PluginLoader).Assembly.GetTypes()
             .Where(t => t.FullName?.Equals($"LabApi.Events.Handlers.{t.Name}") is true)
             .Select(t => t.GetEvents(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public 

Code/FileSystem/FileSystem.cs

@@ -56,8 +56,6 @@ public static void Initialize()
         }
 
         UpdateScriptPathCollection();
-        ScriptFlagHandler.Clear();
-        EventHandler.Clear();
 
         foreach (var scriptPath in RegisteredScriptPaths)
         {

Code/MethodSystem/Methods/CustomRoleMethods/Structures/CRole.cs

@@ -1,17 +1,30 @@
 using LabApi.Events.Arguments.PlayerEvents;
-using LabApi.Events.CustomHandlers;
+using LabApi.Events.Handlers;
 using LabApi.Features.Wrappers;
 using MEC;
 using PlayerRoles;
+using SER.Code.Extensions;
+using SER.Code.Helpers;
 using Random = System.Random;
 
 namespace SER.Code.MethodSystem.Methods.CustomRoleMethods.Structures;
 
-public class CRole : CustomEventsHandler
+public class CRole
 {
     public CRole()
     {
-        CustomHandlersManager.RegisterEventsHandler(this);
+        Log.Signal($"role {GetType().AccurateName} init");
+        PlayerEvents.Death += OnDeath;
+        PlayerEvents.ChangingRole += OnPlayerChangingRole;
+        ServerEvents.RoundStarted += OnServerRoundStarted;
+    }
+
+    public void Unload()
+    {
+        Log.Signal($"role {GetType().AccurateName} deconstr");
+        PlayerEvents.Death -= OnDeath;
+        PlayerEvents.ChangingRole -= OnPlayerChangingRole;
+        ServerEvents.RoundStarted -= OnServerRoundStarted;
     }
 
     public enum CustomRoleEvent
@@ -63,9 +76,10 @@ public static void ResetAll()
     {
         LifeIdAssignedRoles.Clear();
         LastRoles.Clear();
-        RegisteredRoles.Clear();
         PlayersInProcessOfReceivingCRole.Clear();
         EventHandlers.Clear();
+        RegisteredRoles.Values.ForEachItem(role => role.Unload());
+        RegisteredRoles.Clear();
     }
 
     public void AssignPlayer(Player plr)
@@ -124,7 +138,7 @@ private void RunHandlers(CustomRoleEvent @event, Player plr)
         }
     }
 
-    public override void OnServerRoundStarted()
+    public void OnServerRoundStarted()
     {
         Timing.CallDelayed(Timing.WaitForOneFrame, delegate
         {
@@ -202,7 +216,7 @@ private static void HandleRoleRoundStart(CRole role)
         }
     }
 
-    public static void OnDeath(PlayerDeathEventArgs ev)
+    public void OnDeath(PlayerDeathEventArgs ev)
     {
         if (ev.Player is not {} plr) return;
         if (!LifeIdAssignedRoles.TryGetValue(plr.LifeId, out var role)) return;
@@ -211,21 +225,41 @@ public static void OnDeath(PlayerDeathEventArgs ev)
         role.RemovePlayer(plr);
     }
 
-    public override void OnPlayerChangingRole(PlayerChangingRoleEventArgs ev)
+    public void OnPlayerChangingRole(PlayerChangingRoleEventArgs ev)
     {
         if (ev.Player is not {} plr) return;
 
         if (LifeIdAssignedRoles.TryGetValue(plr.LifeId, out var role))
         {
             role.RemovePlayer(plr);
+            Log.Debug($"removing role {Id} from {plr.DisplayName}");
         }
 
-        if (PlayersInProcessOfReceivingCRole.Contains(plr)) return;
-        if (SpawnSystem is not ChanceSpawn chanceSpawn) return;
-        if (ev.NewRole != chanceSpawn.RoleToReplace) return;
-        if (chanceSpawn.SpawnChance <= new Random().NextDouble()) return;
+        if (SpawnSystem is not ChanceSpawn chanceSpawn)
+        {
+            Log.Debug($"{Id} is not a chance spawn system");
+            return;
+        }
+        
+        if (PlayersInProcessOfReceivingCRole.Contains(plr))
+        {
+            Log.Debug($"player {plr.DisplayName} is already in process of receiving role (checking role: {Id})");
+            return;
+        }
+        
+        if (ev.NewRole != chanceSpawn.RoleToReplace)
+        {
+            Log.Debug($"{Id} role cannot work for {plr.DisplayName}, invalid role");
+            return;
+        }
+        if (chanceSpawn.SpawnChance <= new Random().NextDouble())
+        {
+            Log.Debug($"player {plr.DisplayName} failed chance spawn");
+            return;
+        }
 
         ev.IsAllowed = false;
         AssignPlayer(plr);
+        Log.Debug($"player {plr.DisplayName} successfully received role {Id}");
     }
 }

Code/Plugin/MainPlugin.cs

@@ -6,6 +6,7 @@
 using LabApi.Features.Console;
 using MEC;
 using SER.Code.Extensions;
+using SER.Code.FlagSystem;
 using SER.Code.FlagSystem.Flags;
 using SER.Code.Helpers;
 using SER.Code.MethodSystem;
@@ -121,38 +122,44 @@ public override void OnEnabled()
 
         Instance = this;
 
-        Script.StopAll();
-        EventHandler.Initialize();
-        MethodIndex.Initialize();
-        VariableIndex.Initialize();
-        Flag.RegisterFlags();
-        CommandEvents.Initialize();
+
         var fBridge = new FrameworkBridge();
         fBridge.Load();
         SendLogo();
 
+        Events.ServerEvents.MapGenerating += ev =>
+        {
+            Script.StopAll();
+            ScriptFlagHandler.Clear();
+            SetPlayerDataMethod.PlayerData.Clear();
+            TeslaRuleHandler.ResetAll();
+            DamageRuleHandler.ResetAll();
+            CRole.ResetAll();
+            
+            Flag.RegisterFlags();
+            EventHandler.Initialize();
+            MethodIndex.Initialize();
+            VariableIndex.Initialize();
+            CommandEvents.Initialize();
+            FileSystem.FileSystem.Initialize();
+        };
+        
         Events.ServerEvents.WaitingForPlayers += () => OnServerFullyInit(fBridge);
-        Events.ServerEvents.RoundRestarted += PrivateDisable;
         Events.PlayerEvents.Joined += OnJoined;
-
-        FileSystem.FileSystem.Initialize();
+        
         CustomHandlersManager.RegisterEventsHandler(new TeslaRuleHandler());
         CustomHandlersManager.RegisterEventsHandler(new DamageRuleHandler());
     }
 
 #if !EXILED
-    public override void Disable() => PrivateDisable();
+    public override void Disable()
 #else
-    public override void OnDisabled() => PrivateDisable();
+    public override void OnDisabled()
 #endif
-
-    private static void PrivateDisable()
-    {
-        CRole.ResetAll();
+    { 
         Script.StopAll();
-        SetPlayerDataMethod.PlayerData.Clear();
-        TeslaRuleHandler.ResetAll();
-        DamageRuleHandler.ResetAll();
+        ScriptFlagHandler.Clear();
+        EventHandler.Clear();
     }
 
     private void OnServerFullyInit(FrameworkBridge frameworkBridge)