Less shitty disposal hack

Robust.Server/GameStates/ServerGameStateManager.cs

@@ -118,7 +118,7 @@ private void PrintPvsAckInfo(IConsoleShell shell, string argstr, string[] args)
 Actual oldest: {ack}
 Oldest acked clients: {string.Join(", ", players)}
 ");
-            
+
             _nentListPool.Return(deletedNents);
         }
 
@@ -409,7 +409,7 @@ private void SendStateUpdate(int i,
 #endif
             }
 
-            _networkManager.ServerSendMessage(stateUpdateMessage, channel);
+            var canDispose = _networkManager.ServerSendMessage(stateUpdateMessage, channel);
 
             if (stateUpdateMessage.ShouldSendReliably())
             {
@@ -423,23 +423,34 @@ private void SendStateUpdate(int i,
             // Send PVS detach / left-view messages separately and reliably. This is not resistant to packet loss, but
             // unlike game state it doesn't really matter. This also significantly reduces the size of game state
             // messages as PVS chunks get moved out of view.
+            bool leavePvsDispose = true;
+
             if (leftPvs.Count > 0)
             {
                 var pvsMessage = new MsgStateLeavePvs {Entities = leftPvs, Tick = _gameTiming.CurTick};
-                _networkManager.ServerSendMessage(pvsMessage, channel);
+                leavePvsDispose = _networkManager.ServerSendMessage(pvsMessage, channel);
             }
 
             // Release resources
             // Assume everything has been serialized and we're free to rugpull.
-            foreach (var eState in entStates)
+            if (canDispose)
             {
-                _pvs.ReturnEntityState(eState);
-            }
+                // Should this just happen inside PvsSystem instead and store the pools there?
+                // At either rate it needs doing so.
+                foreach (var eState in entStates)
+                {
+                    _pvs.ReturnEntityState(eState);
+                }
 
-            _nentListPool.Return(leftPvs);
-            _nentListPool.Return(deletions);
-            _entStatePool.Return(entStates);
-            _playerStatePool.Return(playerStates);
+                _nentListPool.Return(deletions);
+                _entStatePool.Return(entStates);
+                _playerStatePool.Return(playerStates);
+
+                if (leavePvsDispose)
+                {
+                    _nentListPool.Return(leftPvs);
+                }
+            }
         }
 
         [EventSource(Name = "Robust.Pvs")]

Robust.Shared/Network/INetManager.cs

@@ -86,7 +86,8 @@ public interface INetManager
         /// </summary>
         /// <param name="message">Message to send.</param>
         /// <param name="recipient">Channel to send the message over.</param>
-        void ServerSendMessage(NetMessage message, INetChannel recipient);
+        /// <returns>True if the message is sent and can be disposed.</returns>
+        bool ServerSendMessage(NetMessage message, INetChannel recipient);
 
         /// <summary>
         ///     Sends a message to a collection of channels.

Robust.Shared/Network/NetManager.cs

@@ -1005,12 +1005,12 @@ public void ServerSendToAll(NetMessage message)
         }
 
         /// <inheritdoc />
-        public void ServerSendMessage(NetMessage message, INetChannel recipient)
+        public bool ServerSendMessage(NetMessage message, INetChannel recipient)
         {
             // TODO: Does the entity manager HAVE to shut down after network manager?
             // Though tbf theres no real point in sending messages anymore at that point.
             if (!_initialized)
-                return;
+                return true;
 
             DebugTools.Assert(IsServer);
             if (recipient is not NetChannel channel)
@@ -1024,6 +1024,7 @@ public void ServerSendMessage(NetMessage message, INetChannel recipient)
             var method = message.DeliveryMethod;
             peer.SendMessage(packet, channel.Connection, method);
             LogSend(message, method, packet);
+            return true;
         }
 
         private static void LogSend(NetMessage message, NetDeliveryMethod method, NetOutgoingMessage packet)

Robust.UnitTesting/RobustIntegrationTest.NetManager.cs

@@ -248,53 +248,14 @@ public void ServerSendToAll(NetMessage message)
                 }
             }
 
-            public void ServerSendMessage(NetMessage message, INetChannel recipient)
+            public bool ServerSendMessage(NetMessage message, INetChannel recipient)
             {
                 DebugTools.Assert(IsServer);
 
                 // MsgState sending method depends on the size of the possible compressed buffer. But tests bypass buffer read/write.
                 if (message is MsgState stateMsg)
                 {
                     stateMsg._hasWritten = true;
-
-                    // Clone the message as it gets queued and the data needs to persist for a bit.
-                    var oldState = stateMsg.State;
-
-                    var entStates = new List<EntityState>(oldState.EntityStates.Value?.Count ?? 0);
-                    var sesStates = new List<SessionState>(oldState.PlayerStates.Value?.Count ?? 0);
-                    var deletions = new List<NetEntity>(oldState.EntityDeletions.Value?.Count ?? 0);
-
-                    if (oldState.EntityStates.Value != null)
-                    {
-                        foreach (var state in oldState.EntityStates.Value)
-                        {
-                            entStates.Add(state.Clone());
-                        }
-                    }
-
-                    if (oldState.PlayerStates.Value != null)
-                    {
-                        foreach (var state in oldState.PlayerStates.Value)
-                        {
-                            sesStates.Add(state.Clone());
-                        }
-                    }
-
-                    if (oldState.EntityDeletions.Value != null)
-                    {
-                        foreach (var nent in oldState.EntityDeletions.Value)
-                        {
-                            deletions.Add(nent);
-                        }
-                    }
-
-                    stateMsg.State = new GameState(
-                        oldState.FromSequence,
-                        oldState.ToSequence,
-                        oldState.LastProcessedInput,
-                        entStates.Count == 0 ? null : entStates,
-                        sesStates.Count == 0 ? null : sesStates,
-                        deletions.Count == 0 ? null : deletions);
                 }
 
                 // Clone as above because we don't write immediately in tests.
@@ -305,6 +266,7 @@ public void ServerSendMessage(NetMessage message, INetChannel recipient)
 
                 var channel = (IntegrationNetChannel) recipient;
                 channel.OtherChannel.TryWrite(new DataMessage(message, channel.RemoteUid));
+                return false;
             }
 
             public void ServerSendToMany(NetMessage message, List<INetChannel> recipients)