performance: optimize packet broadcasting by caching entity state snapshots

- Add snapshot caching for entity stats, vitals, and player equipment
- Skip redundant broadcasts when state hasn't changed since last send
- Clear snapshots when entities leave map/layer/instance
- Batch vital updates to only include entities with actual changes
- Equipment broadcasts now only send when items visually change

This reduces network bandwidth and server CPU during high-entity scenarios
(raids, events, crowded maps) by eliminating unnecessary/duped tx of packets
to proximity clients while preserving first-send guarantees and correctness.
Changes are backward-compatible; clients see no behavioral difference, only faster network synchronization and lower latency impact from packets broadcasting.

Signed-off-by: Arufonsu <17498701+Arufonsu@users.noreply.github.com>

Author: Arufonsu

Intersect.Server.Core/Networking/PacketSender.cs

@@ -12,7 +12,6 @@
 using Intersect.Framework.Core.GameObjects.PlayerClass;
 using Intersect.Framework.Core.GameObjects.Resources;
 using Intersect.Framework.Core.GameObjects.Variables;
-using Intersect.Framework.Core.Network.Packets.Security;
 using Intersect.Framework.Core.Security;
 using Intersect.GameObjects;
 using Intersect.Models;
@@ -27,7 +26,6 @@
 using Intersect.Server.General;
 using Intersect.Server.Localization;
 using Intersect.Server.Maps;
-using Intersect.Utilities;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
@@ -53,6 +51,19 @@ public static void ResetMetrics()
         SentBytes = 0;
     }
 
+    //Tracks last sent stats per entity so we can skip redundant packet updates.
+    private sealed record EntityStatsSnapshot(int[] Stats);
+
+    private static readonly Dictionary<Guid, EntityStatsSnapshot> _lastEntityStatsSnapshot = new Dictionary<Guid, EntityStatsSnapshot>();
+
+    // Tracks last sent vitals per entity for map‑wide batch updates.
+    private sealed record EntityVitalSnapshot(long[] Vitals, long[] MaxVitals, long CombatTimeRemaining);
+
+    private static readonly Dictionary<Guid, EntityVitalSnapshot> _lastEntityVitalSnapshot = new Dictionary<Guid, EntityVitalSnapshot>();
+
+    // Tracks last sent equipment item ids per player.
+    private static readonly Dictionary<Guid, Guid[]> _lastPlayerEquipmentSnapshot = new Dictionary<Guid, Guid[]>();
+
     //PingPacket
     public static void SendPing(Client client, bool request = true)
     {
@@ -640,24 +651,28 @@ public static void SendNpcAggressionTo(Player player, Npc npc)
     public static void SendEntityLeaveMap(Entity en, Guid leftMap)
     {
         SendDataToMapInstance(leftMap, en.MapInstanceId, new EntityLeftPacket(en.Id, en.GetEntityType(), en.MapId));
+        ClearEntitySnapshotCache(en);
     }
 
     //EntityLeftPacket
     public static void SendEntityLeave(Entity en)
     {
         SendDataToProximityOnMapInstance(en.MapId, en.MapInstanceId, new EntityLeftPacket(en.Id, en.GetEntityType(), en.MapId));
+        ClearEntitySnapshotCache(en);
     }
 
     //EntityLeftPacket
     public static void SendEntityLeaveLayer(Entity en, Guid mapInstanceId)
     {
         SendDataToProximityOnMapInstance(en.MapId, mapInstanceId, new EntityLeftPacket(en.Id, en.GetEntityType(), en.MapId));
+        ClearEntitySnapshotCache(en);
     }
 
     //EntityLeftPacket
     public static void SendEntityLeaveInstanceOfMap(Entity en, Guid mapId, Guid mapInstanceId)
     {
         SendDataToProximityOnMapInstance(mapId, mapInstanceId, new EntityLeftPacket(en.Id, en.GetEntityType(), en.MapId));
+        ClearEntitySnapshotCache(en);
     }
 
     //EntityLeavePacket
@@ -772,6 +787,16 @@ public static void CacheGameDataPacket()
         CachedGameDataPacket = new GameDataPacket(gameObjects.ToArray(), CustomColors.Json());
     }
 
+    private static void ClearEntitySnapshotCache(Entity en)
+    {
+        if (en != null)
+        {
+            _lastEntityStatsSnapshot.Remove(en.Id);
+            _lastEntityVitalSnapshot.Remove(en.Id);
+            _lastPlayerEquipmentSnapshot.Remove(en.Id);
+        }
+    }
+
     /// <summary>
     /// Sends a global chat message to every user online.
     /// </summary>
@@ -945,22 +970,56 @@ public static EntityVitalsPacket GenerateEntityVitalsPacket(Entity en)
     //EntityVitalsPacket
     public static void SendMapEntityVitalUpdate(MapController map, Entity[] entities, Guid mapInstanceId)
     {
-        // Generate a list of vitals to send to our users!
+        if (map == null || entities == null || entities.Length == 0)
+        {
+            return;
+        }
+
         var data = new List<EntityVitalData>();
+
         foreach (var entity in entities)
         {
-            data.Add(new EntityVitalData()
+            if (entity == null)
             {
-                Id = entity.Id,
-                Type = entity.GetEntityType(),
-                Vitals = entity.GetVitals(),
-                MaxVitals = entity.GetMaxVitals(),
-                CombatTimeRemaining = entity.CombatTimer - Timing.Global.Milliseconds
-            });
+                continue;
+            }
+
+            var vitals = entity.GetVitals();
+            var maxVitals = entity.GetMaxVitals();
+            var combatRemaining = entity.CombatTimer - Timing.Global.Milliseconds;
+
+            var newSnapshot = new EntityVitalSnapshot(vitals, maxVitals, combatRemaining);
+
+            if (_lastEntityVitalSnapshot.TryGetValue(entity.Id, out var oldSnapshot))
+            {
+                if (oldSnapshot.Vitals.SequenceEqual(newSnapshot.Vitals) &&
+                    oldSnapshot.MaxVitals.SequenceEqual(newSnapshot.MaxVitals) &&
+                    oldSnapshot.CombatTimeRemaining == newSnapshot.CombatTimeRemaining)
+                {
+                    // Nothing relevant changed, skip this entity.
+                    continue;
+                }
+            }
+
+            _lastEntityVitalSnapshot[entity.Id] = newSnapshot;
+
+            data.Add(
+                new EntityVitalData
+                {
+                    Id = entity.Id,
+                    Type = entity.GetEntityType(),
+                    Vitals = vitals,
+                    MaxVitals = maxVitals,
+                    CombatTimeRemaining = combatRemaining
+                }
+            );
         }
 
-        // Send the data to the surroundings!
-        SendDataToProximityOnMapInstance(map.Id, mapInstanceId, new MapEntityVitalsPacket(map.Id, data.ToArray()));
+        // Only send if at least one entity actually changed.
+        if (data.Count > 0)
+        {
+            SendDataToProximityOnMapInstance(map.Id, mapInstanceId, new MapEntityVitalsPacket(map.Id, data.ToArray()));
+        }
     }
 
     public static void SendMapEntityStatusUpdate(MapController map, Entity[] entities, Guid mapInstanceId)
@@ -989,7 +1048,26 @@ public static void SendEntityStats(Entity en)
             return;
         }
 
-        SendDataToProximityOnMapInstance(en.MapId, en.MapInstanceId, GenerateEntityStatsPacket(en), null, TransmissionMode.Any);
+        // Build current stats array (same logic as GenerateEntityStatsPacket)
+        var stats = new int[Enum.GetValues<Stat>().Length];
+        for (var i = 0; i < stats.Length; i++)
+        {
+            stats[i] = en.Stat[i].Value();
+        }
+
+        var newSnapshot = new EntityStatsSnapshot(stats);
+
+        if (_lastEntityStatsSnapshot.TryGetValue(en.Id, out var oldSnapshot))
+        {
+            if (oldSnapshot.Stats.SequenceEqual(newSnapshot.Stats))
+            {
+                // No visible stat changes; skip the packet update entirely.
+                return;
+            }
+        }
+
+        _lastEntityStatsSnapshot[en.Id] = newSnapshot;
+        SendDataToProximityOnMapInstance(en.MapId, en.MapInstanceId, new EntityStatsPacket(en.Id, en.GetEntityType(), en.MapId, stats), null, TransmissionMode.Any);
     }
 
     //EntityVitalsPacket
@@ -1295,6 +1373,36 @@ public static void SendPlayerEquipmentTo(Player forPlayer, Player en)
     //EquipmentPacket
     public static void SendPlayerEquipmentToProximity(Player en)
     {
+        if (en == null)
+        {
+            return;
+        }
+
+        var slots = Options.Instance.Equipment.Slots.Count;
+        var equipment = new Guid[slots];
+
+        for (var i = 0; i < slots; i++)
+        {
+            if (en.Equipment[i] == -1 || en.Items[en.Equipment[i]].ItemId == Guid.Empty)
+            {
+                equipment[i] = Guid.Empty;
+            }
+            else
+            {
+                equipment[i] = en.Items[en.Equipment[i]].ItemId;
+            }
+        }
+
+        if (_lastPlayerEquipmentSnapshot.TryGetValue(en.Id, out var last))
+        {
+            if (last.Length == equipment.Length && last.SequenceEqual(equipment))
+            {
+                // Nothing changed, skip entirely.
+                return;
+            }
+        }
+
+        _lastPlayerEquipmentSnapshot[en.Id] = equipment;
         SendDataToProximityOnMapInstance(en.MapId, en.MapInstanceId, GenerateEquipmentPacket(null, en), null, TransmissionMode.Any);
         SendPlayerEquipmentTo(en, en);
     }