Add optional full force client update path

- Updated markdown files.
- Added FullForceUpdate as an optional feature.
- Jester: Fixes crashes that occur when a skill is being disabled.

jRandomSkills - SRC Files/src/utils/CServerSideClient.cs

@@ -0,0 +1,107 @@
+// https://discord.com/channels/1160907911501991946/1508172390863994910/1508180670659166348
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using CounterStrikeSharp.API;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Modules.Memory;
+
+namespace jRandomSkills.src.utils
+{
+
+    #region Native Structs
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe struct CUtlMemory<T> where T : unmanaged
+    {
+        public T* m_pMemory;
+        public int m_nAllocationCount;
+        public int m_nGrowSize;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe struct CUtlVector<T> where T : unmanaged
+    {
+        public int m_Size;
+        public CUtlMemory<T> m_Memory;
+
+        public int Count => m_Size;
+
+        public ref T Element(int index)
+        {
+            if (index < 0 || index >= m_Size)
+                throw new IndexOutOfRangeException();
+
+            if (m_Memory.m_pMemory == null)
+                throw new NullReferenceException("m_pMemory is null. The vector is empty or the GameData offset is outdated.");
+
+            return ref m_Memory.m_pMemory[index];
+        }
+    }
+
+    #endregion
+
+    #region Network Services
+
+    public class INetworkServerService : NativeObject
+    {
+        private readonly VirtualFunctionWithReturn<nint, nint> GetIGameServerFunc;
+
+        public INetworkServerService() : base(NativeAPI.GetValveInterface(0, "NetworkServerService_001"))
+        {
+            GetIGameServerFunc = new VirtualFunctionWithReturn<nint, nint>(Handle, GameData.GetOffset("INetworkServerService_GetIGameServer"));
+        }
+
+        public INetworkGameServer GetIGameServer()
+        {
+            return new INetworkGameServer(GetIGameServerFunc.Invoke(Handle));
+        }
+    }
+
+    public unsafe class INetworkGameServer(nint ptr) : NativeObject(ptr)
+    {
+        private static readonly int SlotsOffset = GameData.GetOffset("INetworkGameServer_Slots");
+
+        private ref CUtlVector<nint> Slots => ref Unsafe.AsRef<CUtlVector<nint>>((void*)(Handle + SlotsOffset));
+
+        public CServerSideClient? GetClientBySlot(int slot)
+        {
+            if (Handle == nint.Zero)
+                return null;
+
+            if (slot < 0 || slot >= Slots.Count || Slots.m_Memory.m_pMemory == null)
+                return null;
+
+            var ptr = Slots.Element(slot);
+
+            if (ptr == nint.Zero)
+                return null;
+
+            return new CServerSideClient(ptr);
+        }
+    }
+
+    #endregion
+
+    #region CServerSideClient
+
+    public unsafe class CServerSideClient(nint ptr) : NativeObject(ptr)
+    {
+        private static readonly int m_nDeltaTick = GameData.GetOffset("CServerSideClient_m_nDeltaTick");
+
+        private ref T Field<T>(int offset) where T : unmanaged
+        {
+            return ref Unsafe.AsRef<T>((void*)(Handle + offset));
+        }
+
+        public int DeltaTick
+        {
+            get => Field<int>(m_nDeltaTick);
+            set => Field<int>(m_nDeltaTick) = value;
+        }
+
+        public void ForceFullUpdate() => DeltaTick = -1;
+    }
+
+    #endregion
+}

jRandomSkills - SRC Files/src/utils/Config.cs

@@ -79,6 +79,7 @@ namespace src.utils
             public bool SummaryAfterTheRound { get; set; }
             public bool EnableBotSkills { get; set; }
             public bool EnableBotKickDebug { get; set; }
+            public bool EnableFullForceUpdate { get; set; }
             public bool DebugMode { get; set; }
             public bool PerfMode { get; set; }
             public string? AlternativeSkillButton { get; set; }
@@ -107,6 +108,7 @@ namespace src.utils
                 SummaryAfterTheRound = true;
                 EnableBotSkills = true;
                 EnableBotKickDebug = false;
+                EnableFullForceUpdate = false;
                 DebugMode = false;
                 PerfMode = false;
                 AlternativeSkillButton = null;

jRandomSkills - SRC Files/src/utils/SkillUtils.cs

@@ -333,6 +333,79 @@ namespace src.utils
             return EntityManager.CreateTrackedTrigger(ownerPlayerIndex, name, radius, pos);
         }
 
+        public static void ForceFullUpdate(CCSPlayerController player, List<(uint PlayerIndex, QAngle LastAngle)>? batchList = null, INetworkGameServer? networkGameServer = null)
+        {
+            if (!Config.LoadedConfig.EnableFullForceUpdate) return;
+            if (player == null || !player.IsValid) return;
+
+            var pawn = player.PlayerPawn?.Value;
+            if (pawn == null || !pawn.IsValid || pawn.AbsOrigin == null) return;
+
+            QAngle lastAngle = new(pawn.V_angle.X, pawn.V_angle.Y, pawn.V_angle.Z);
+
+            networkGameServer ??= new INetworkServerService().GetIGameServer();
+
+            var client = networkGameServer.GetClientBySlot(player.Slot);
+            if (client == null) return;
+
+            client.ForceFullUpdate();
+            // Only skip the angle restore when the captured view is a spawn-time (0,0,0) placeholder;
+            // a genuine angle with a single zero component (e.g. yaw exactly 0) must still be restored.
+            if (lastAngle.X == 0 && lastAngle.Y == 0 && lastAngle.Z == 0) return;
+
+            uint playerIndex = player.Index;
+
+            if (batchList != null)
+            {
+                batchList.Add((playerIndex, lastAngle));
+                return;
+            }
+
+            jRandomSkills.Instance.AddTickTimer(3, () =>
+            {
+                var target = Utilities.GetPlayerFromIndex((int)playerIndex);
+                if (target == null || !target.IsValid) return;
+
+                var targetPawn = target.PlayerPawn?.Value;
+                if (targetPawn == null || !targetPawn.IsValid || targetPawn.AbsOrigin == null) return;
+
+                targetPawn.Look(lastAngle);
+            });
+        }
+
+        private static int lastForceFullUpdateAll = int.MinValue;
+
+        public static void ForceFullUpdateToAll()
+        {
+            if (!Config.LoadedConfig.EnableFullForceUpdate) return;
+
+            int tickCount = Server.TickCount;
+            if (tickCount == lastForceFullUpdateAll) return;
+
+            lastForceFullUpdateAll = tickCount;
+            var playersToRestore = new List<(uint PlayerIndex, QAngle LastAngle)>();
+
+            INetworkGameServer networkGameServer = new INetworkServerService().GetIGameServer();
+            foreach (var player in Utilities.GetPlayers())
+                ForceFullUpdate(player, playersToRestore, networkGameServer);
+
+            if (playersToRestore.Count <= 0) return;
+
+            jRandomSkills.Instance.AddTickTimer(3, () =>
+            {
+                foreach (var item in playersToRestore)
+                {
+                    var target = Utilities.GetPlayerFromIndex((int)item.PlayerIndex);
+                    if (target == null || !target.IsValid) continue;
+
+                    var targetPawn = target.PlayerPawn?.Value;
+                    if (targetPawn == null || !targetPawn.IsValid || targetPawn.AbsOrigin == null) continue;
+
+                    targetPawn.Look(item.LastAngle);
+                }
+            });
+        }
+
         public static bool SetHealth(CCSPlayerPawn? pawn, int newHealth, int? maxHealth = null)
         {
             if (pawn == null || !pawn.IsValid)