Dev (#152)

* fix (#147)

Co-authored-by: VALERA771 <[email protected]>

* ``[EXILED::API]`` Fixing NPC PlayerId assignment (#135)

* spawn fix (#148)

* ueu (#149)

---------

Co-authored-by: Misaka-ZeroTwo <[email protected]>
Co-authored-by: SrLicht <[email protected]>

EXILED/Exiled.API/Features/Npc.cs

@@ -16,7 +16,6 @@ namespace Exiled.API.Features
     using CentralAuth;
     using CommandSystem;
     using Exiled.API.Enums;
-    using Exiled.API.Extensions;
     using Exiled.API.Features.Components;
     using Exiled.API.Features.Roles;
     using Footprinting;
@@ -142,6 +141,7 @@ public override Vector3 Position
         /// <param name="userId">The userID of the NPC.</param>
         /// <param name="position">The position to spawn the NPC.</param>
         /// <returns>The <see cref="Npc"/> spawned.</returns>
+        [Obsolete("This metod is marked as obsolet due to a bug that make player have the same id. Use Npc.Spawn(string) instead")]
         public static Npc Spawn(string name, RoleTypeId role, int id = 0, string userId = PlayerAuthenticationManager.DedicatedId, Vector3? position = null)
         {
             GameObject newObject = UnityEngine.Object.Instantiate(Mirror.NetworkManager.singleton.playerPrefab);
@@ -208,18 +208,118 @@ public static Npc Spawn(string name, RoleTypeId role, int id = 0, string userId
             return npc;
         }
 
+        /// <summary>
+        /// Spawns an NPC based on the given parameters.
+        /// </summary>
+        /// <param name="name">The name of the NPC.</param>
+        /// <param name="role">The RoleTypeId of the NPC, defaulting to None.</param>
+        /// <param name="ignored">Whether the NPC should be ignored by round ending checks.</param>
+        /// <param name="userId">The userID of the NPC for authentication. Defaults to the Dedicated ID.</param>
+        /// <param name="position">The position where the NPC should spawn. If null, the default spawn location is used.</param>
+        /// <returns>The <see cref="Npc"/> spawned.</returns>
+        public static Npc Spawn(string name, RoleTypeId role = RoleTypeId.None, bool ignored = false, string userId = PlayerAuthenticationManager.DedicatedId, Vector3? position = null)
+        {
+            GameObject newObject = UnityEngine.Object.Instantiate(Mirror.NetworkManager.singleton.playerPrefab);
+
+            Npc npc = new(newObject)
+            {
+                IsNPC = true,
+            };
+
+            FakeConnection fakeConnection = new(npc.Id);
+
+            try
+            {
+                if (userId == PlayerAuthenticationManager.DedicatedId)
+                {
+                    npc.ReferenceHub.authManager.SyncedUserId = userId;
+                    try
+                    {
+                        npc.ReferenceHub.authManager.InstanceMode = ClientInstanceMode.DedicatedServer;
+                    }
+                    catch (Exception e)
+                    {
+                        Log.Debug($"Ignore: {e.Message}");
+                    }
+                }
+                else
+                {
+                    npc.ReferenceHub.authManager.InstanceMode = ClientInstanceMode.Unverified;
+                    npc.ReferenceHub.authManager._privUserId = userId == string.Empty ? $"Dummy-{npc.Id}@localhost" : userId;
+                }
+            }
+            catch (Exception e)
+            {
+                Log.Debug($"Ignore: {e.Message}");
+            }
+
+            try
+            {
+                npc.ReferenceHub.roleManager.InitializeNewRole(RoleTypeId.None, RoleChangeReason.None);
+            }
+            catch (Exception e)
+            {
+                Log.Debug($"Ignore: {e.Message}");
+            }
+
+            NetworkServer.AddPlayerForConnection(fakeConnection, newObject);
+
+            npc.ReferenceHub.nicknameSync.Network_myNickSync = name;
+            Dictionary.Add(newObject, npc);
+
+            Timing.CallDelayed(0.5f, () =>
+            {
+                npc.Role.Set(role, SpawnReason.RoundStart, position is null ? RoleSpawnFlags.All : RoleSpawnFlags.AssignInventory);
+
+                if (position is not null)
+                    npc.Position = position.Value;
+            });
+
+            if (ignored)
+                Round.IgnoredPlayers.Add(npc.ReferenceHub);
+
+            return npc;
+        }
+
+        /// <summary>
+        /// Destroys all NPCs currently spawned.
+        /// </summary>
+        public static void DestroyAll()
+        {
+            foreach (Npc npc in List)
+                npc.Destroy();
+        }
+
         /// <summary>
         /// Destroys the NPC.
         /// </summary>
         public void Destroy()
         {
-            NetworkConnectionToClient conn = ReferenceHub.connectionToClient;
-            if (ReferenceHub._playerId.Value <= RecyclablePlayerId._autoIncrement)
-                ReferenceHub._playerId.Destroy();
-            ReferenceHub.OnDestroy();
-            CustomNetworkManager.TypedSingleton.OnServerDisconnect(conn);
-            Dictionary.Remove(GameObject);
-            Object.Destroy(GameObject);
+            try
+            {
+                Round.IgnoredPlayers.Remove(ReferenceHub);
+                NetworkConnectionToClient conn = ReferenceHub.connectionToClient;
+                ReferenceHub.OnDestroy();
+                CustomNetworkManager.TypedSingleton.OnServerDisconnect(conn);
+                Dictionary.Remove(GameObject);
+                Object.Destroy(GameObject);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"Error while destroying a NPC: {e.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Schedules the destruction of the NPC after a delay.
+        /// </summary>
+        /// <param name="time">The delay in seconds before the NPC is destroyed.</param>
+        public void LateDestroy(float time)
+        {
+            Timing.CallDelayed(time, () =>
+            {
+                this?.Destroy();
+            });
         }
     }
 }

EXILED/Exiled.Events/Patches/Events/Player/ChangingRoleAndSpawned.cs

@@ -44,6 +44,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             Label returnLabel = generator.DefineLabel();
             Label continueLabel = generator.DefineLabel();
             Label jmp = generator.DefineLabel();
+            Label skip = generator.DefineLabel();
 
             LocalBuilder changingRoleEventArgs = generator.DeclareLocal(typeof(ChangingRoleEventArgs));
             LocalBuilder player = generator.DeclareLocal(typeof(API.Features.Player));
@@ -155,8 +156,16 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 newInstructions.Count - 1,
                 new[]
                 {
+                    // if (player.ReferenceHub == ReferenceHub.LocalHub)
+                    //     goto skip;
+                    new(OpCodes.Ldloc_S, player.LocalIndex),
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(API.Features.Player), nameof(API.Features.Player.ReferenceHub))),
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(ReferenceHub), nameof(ReferenceHub.LocalHub))),
+                    new(OpCodes.Call, Method(typeof(ReferenceHub), "op_Equality")),
+                    new(OpCodes.Brtrue_S, skip),
+
                     // player
-                    new CodeInstruction(OpCodes.Ldloc_S, player.LocalIndex),
+                    new(OpCodes.Ldloc_S, player.LocalIndex),
 
                     // OldRole
                     new(OpCodes.Ldloc_0),
@@ -166,6 +175,8 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
                     // Handlers.Player.OnSpawned(spawnedEventArgs)
                     new(OpCodes.Call, Method(typeof(Player), nameof(Player.OnSpawned))),
+
+                    new CodeInstruction(OpCodes.Nop).WithLabels(skip),
                 });
 
             newInstructions[newInstructions.Count - 1].labels.Add(returnLabel);

EXILED/Exiled.Events/Patches/Events/Server/Reporting.cs

@@ -84,7 +84,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     new(OpCodes.Starg_S, 2),
                 });
 
-            offset = -2;
+            offset = -11;
             index = newInstructions.FindLastIndex(
                 instruction => instruction.StoresField(Field(typeof(CheaterReport), nameof(CheaterReport._lastReport)))) + offset;
 

EXILED/Exiled.Loader/Loader.cs

@@ -394,7 +394,17 @@ public IEnumerator<float> Run(Assembly[] dependencies = null)
                 GameCore.Version.BackwardCompatibility,
                 GameCore.Version.BackwardRevision))
             {
-                ServerConsole.AddLog($"Exiled is outdated, a new version will be installed automatically as soon as it's available.\nSCP:SL: {GameCore.Version.VersionString} Exiled Supported Version: {AutoUpdateFiles.RequiredSCPSLVersion}", ConsoleColor.DarkRed);
+                string messageText = new Version(
+                    GameCore.Version.Major,
+                    GameCore.Version.Minor,
+                    GameCore.Version.Revision) < new Version(
+                    AutoUpdateFiles.RequiredSCPSLVersion.Major,
+                    AutoUpdateFiles.RequiredSCPSLVersion.Minor,
+                    AutoUpdateFiles.RequiredSCPSLVersion.Revision)
+                            ? "SCP: SL is outdated. Update SCP: SL Dedicated Server to required version or downgrade Exiled."
+                            : "Exiled is outdated, a new version will be installed automatically as soon as it's available.";
+
+                ServerConsole.AddLog($"{messageText}\nSCP:SL version: {GameCore.Version.VersionString} Exiled Supported Version: {AutoUpdateFiles.RequiredSCPSLVersion}", ConsoleColor.DarkRed);
                 yield break;
             }