Unstable v0.19.3.0

2022-09-02 15:10:56 -03:00
parent 28789616bd
commit 3f2c843247
336 changed files with 7152 additions and 7739 deletions
@@ -1,21 +1,22 @@
-using Barotrauma.Steam;
-using Lidgren.Network;
+#nullable enable
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Lidgren.Network;
+using Barotrauma.Steam;

 namespace Barotrauma.Networking
 {
-    class LidgrenClientPeer : ClientPeer
+    internal sealed class LidgrenClientPeer : ClientPeer
    {
        private bool isActive;
-        private NetClient netClient;
-        private NetPeerConfiguration netPeerConfiguration;
+        private NetClient? netClient;
+        private readonly NetPeerConfiguration netPeerConfiguration;

-        List<NetIncomingMessage> incomingLidgrenMessages;
+        private readonly List<NetIncomingMessage> incomingLidgrenMessages;

-        private LidgrenEndpoint lidgrenEndpoint
-            => ServerConnection is LidgrenConnection { Endpoint: LidgrenEndpoint result }
+        private LidgrenEndpoint lidgrenEndpoint =>
+            ServerConnection is LidgrenConnection { Endpoint: LidgrenEndpoint result }
                ? result
                : throw new InvalidOperationException();

@@ -25,13 +26,6 @@ namespace Barotrauma.Networking

            netClient = null;
            isActive = false;
-        }
-
-        public override void Start()
-        {
-            if (isActive) { return; }
-
-            ContentPackageOrderReceived = false;

            netPeerConfiguration = new NetPeerConfiguration("barotrauma")
            {
@@ -45,6 +39,17 @@ namespace Barotrauma.Networking
                | NetIncomingMessageType.ErrorMessage
                | NetIncomingMessageType.Error);

+            incomingLidgrenMessages = new List<NetIncomingMessage>();
+        }
+
+        public override void Start()
+        {
+            if (isActive) { return; }
+
+            incomingLidgrenMessages.Clear();
+
+            ContentPackageOrderReceived = false;
+
            netClient = new NetClient(netPeerConfiguration);

            if (SteamManager.IsInitialized)
@@ -56,14 +61,13 @@ namespace Barotrauma.Networking
                }
            }

-            incomingLidgrenMessages = new List<NetIncomingMessage>();
-
            initializationStep = ConnectionInitialization.SteamTicketAndVersion;

-            if (!(ServerEndpoint is LidgrenEndpoint lidgrenEndpoint))
+            if (!(ServerEndpoint is LidgrenEndpoint lidgrenEndpointValue))
            {
-                throw new InvalidCastException("endPoint is not IPEndPoint");
+                throw new InvalidCastException($"Endpoint is not {nameof(LidgrenEndpoint)}");
            }
+
            if (ServerConnection != null)
            {
                throw new InvalidOperationException("ServerConnection is not null");
@@ -71,8 +75,8 @@ namespace Barotrauma.Networking

            netClient.Start();

-            var netConnection = netClient.Connect(lidgrenEndpoint.NetEndpoint);
-            
+            var netConnection = netClient.Connect(lidgrenEndpointValue.NetEndpoint);
+
            ServerConnection = new LidgrenConnection(netConnection)
            {
                Status = NetworkConnectionStatus.Connected
@@ -85,11 +89,18 @@ namespace Barotrauma.Networking
        {
            if (!isActive) { return; }

+            ToolBox.ThrowIfNull(netClient);
+            ToolBox.ThrowIfNull(incomingLidgrenMessages);
+
            if (isOwner && !(ChildServerRelay.Process is { HasExited: false }))
            {
                Close();
                var msgBox = new GUIMessageBox(TextManager.Get("ConnectionLost"), ChildServerRelay.CrashMessage);
-                msgBox.Buttons[0].OnClicked += (btn, obj) => { GameMain.MainMenuScreen.Select(); return false; };
+                msgBox.Buttons[0].OnClicked += (btn, obj) =>
+                {
+                    GameMain.MainMenuScreen.Select();
+                    return false;
+                };
                return;
            }

@@ -101,7 +112,11 @@ namespace Barotrauma.Networking

            foreach (NetIncomingMessage inc in incomingLidgrenMessages)
            {
-                if (!inc.SenderConnection.RemoteEndPoint.Equals(lidgrenEndpoint.NetEndpoint)) { continue; }
+                if (!inc.SenderConnection.RemoteEndPoint.Equals(lidgrenEndpoint.NetEndpoint))
+                {
+                    DebugConsole.AddWarning($"Mismatched endpoint: expected {lidgrenEndpoint.NetEndpoint}, got {inc.SenderConnection.RemoteEndPoint}");
+                    continue;
+                }

                switch (inc.MessageType)
                {
@@ -115,15 +130,23 @@ namespace Barotrauma.Networking
            }
        }

-        private void HandleDataMessage(NetIncomingMessage inc)
+        private void HandleDataMessage(NetIncomingMessage lidgrenMsg)
        {
            if (!isActive) { return; }

-            PacketHeader packetHeader = (PacketHeader)inc.ReadByte();
+            ToolBox.ThrowIfNull(ServerConnection);
+
+            IReadMessage inc = lidgrenMsg.ToReadMessage();
+
+            var (_, packetHeader, initialization) = INetSerializableStruct.Read<PeerPacketHeaders>(inc);

            if (packetHeader.IsConnectionInitializationStep() && initializationStep != ConnectionInitialization.Success)
            {
-                ReadConnectionInitializationStep(new ReadWriteMessage(inc.Data, (int)inc.Position, inc.LengthBits, false));
+                ReadConnectionInitializationStep(new IncomingInitializationMessage
+                {
+                    InitializationStep = initialization ?? throw new Exception("Initialization step missing"),
+                    Message = inc
+                });
            }
            else
            {
@@ -132,9 +155,9 @@ namespace Barotrauma.Networking
                    callbacks.OnInitializationComplete.Invoke();
                    initializationStep = ConnectionInitialization.Success;
                }
-                UInt16 length = inc.ReadUInt16();
-                IReadMessage msg = new ReadOnlyMessage(inc.Data, packetHeader.IsCompressed(), inc.PositionInBytes, length, ServerConnection);
-                callbacks.OnMessageReceived.Invoke(msg);
+
+                var packet = INetSerializableStruct.Read<PeerPacketMessage>(inc);
+                callbacks.OnMessageReceived.Invoke(packet.GetReadMessage(packetHeader.IsCompressed(), ServerConnection));
            }
        }

@@ -142,7 +165,7 @@ namespace Barotrauma.Networking
        {
            if (!isActive) { return; }

-            NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
+            NetConnectionStatus status = inc.ReadHeader<NetConnectionStatus>();
            switch (status)
            {
                case NetConnectionStatus.Disconnected:
@@ -157,29 +180,38 @@ namespace Barotrauma.Networking
        {
            if (!isActive) { return; }

+            ToolBox.ThrowIfNull(netClient);
+
            if (initializationStep != ConnectionInitialization.Password) { return; }
-            NetOutgoingMessage outMsg = netClient.CreateMessage();
-            outMsg.Write((byte)PacketHeader.IsConnectionInitializationStep);
-            outMsg.Write((byte)ConnectionInitialization.Password);
-            byte[] saltedPw = ServerSettings.SaltPassword(Encoding.UTF8.GetBytes(password), passwordSalt);
-            outMsg.Write((byte)saltedPw.Length);
-            outMsg.Write(saltedPw, 0, saltedPw.Length);
-            NetSendResult result = netClient.SendMessage(outMsg, NetDeliveryMethod.ReliableUnordered);
-            if (result != NetSendResult.Queued && result != NetSendResult.Sent)
+
+            var headers = new PeerPacketHeaders
            {
-                DebugConsole.NewMessage("Failed to send " + initializationStep.ToString() + " message to host: " + result);
-            }
+                DeliveryMethod = DeliveryMethod.Reliable,
+                PacketHeader = PacketHeader.IsConnectionInitializationStep,
+                Initialization = ConnectionInitialization.Password
+            };
+            var body = new ClientPeerPasswordPacket
+            {
+                Password = ServerSettings.SaltPassword(Encoding.UTF8.GetBytes(password), passwordSalt)
+            };
+            
+            SendMsgInternal(headers, body);
        }

-        public override void Close(string msg = null, bool disableReconnect = false)
+        public override void Close(string? msg = null, bool disableReconnect = false)
        {
            if (!isActive) { return; }

+            ToolBox.ThrowIfNull(netClient);
+
            isActive = false;

            netClient.Shutdown(msg ?? TextManager.Get("Disconnecting").Value);
            netClient = null;
-            steamAuthTicket?.Cancel(); steamAuthTicket = null;
+
+            steamAuthTicket?.Cancel();
+            steamAuthTicket = null;
+
            callbacks.OnDisconnect.Invoke(disableReconnect);
        }

@@ -187,19 +219,8 @@ namespace Barotrauma.Networking
        {
            if (!isActive) { return; }

-            NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
-            switch (deliveryMethod)
-            {
-                case DeliveryMethod.Unreliable:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
-                    break;
-                case DeliveryMethod.Reliable:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
-                    break;
-                case DeliveryMethod.ReliableOrdered:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
-                    break;
-            }
+            ToolBox.ThrowIfNull(netClient);
+            ToolBox.ThrowIfNull(netPeerConfiguration);

 #if DEBUG
            netPeerConfiguration.SimulatedDuplicatesChance = GameMain.Client.SimulatedDuplicatesChance;
@@ -208,30 +229,42 @@ namespace Barotrauma.Networking
            netPeerConfiguration.SimulatedLoss = GameMain.Client.SimulatedLoss;
 #endif

-            NetOutgoingMessage lidgrenMsg = netClient.CreateMessage();
-            byte[] msgData = new byte[msg.LengthBytes];
-            msg.PrepareForSending(ref msgData, compressPastThreshold, out bool isCompressed, out int length);
-            lidgrenMsg.Write((byte)(isCompressed ? PacketHeader.IsCompressed : PacketHeader.None));
-            lidgrenMsg.Write((UInt16)length);
-            lidgrenMsg.Write(msgData, 0, length);
+            byte[] bufAux = msg.PrepareForSending(compressPastThreshold, out bool isCompressed, out _);

-            NetSendResult result = netClient.SendMessage(lidgrenMsg, lidgrenDeliveryMethod);
+            var headers = new PeerPacketHeaders
+            {
+                DeliveryMethod = deliveryMethod,
+                PacketHeader = isCompressed ? PacketHeader.IsCompressed : PacketHeader.None,
+                Initialization = null
+            };
+            var body = new PeerPacketMessage
+            {
+                Buffer = bufAux
+            };
+            
+            SendMsgInternal(headers, body);
+        }
+
+        protected override void SendMsgInternal(PeerPacketHeaders headers, INetSerializableStruct? body)
+        {
+            ToolBox.ThrowIfNull(netClient);
+
+            IWriteMessage msg = new WriteOnlyMessage();
+            msg.WriteNetSerializableStruct(headers);
+            body?.Write(msg);
+
+            NetSendResult result = ForwardToLidgren(msg, DeliveryMethod.Reliable);
            if (result != NetSendResult.Queued && result != NetSendResult.Sent)
            {
-                DebugConsole.NewMessage("Failed to send message to host: " + result);
+                DebugConsole.NewMessage($"Failed to send message to host: {result}\n{Environment.StackTrace}");
            }
        }

-        protected override void SendMsgInternal(DeliveryMethod deliveryMethod, IWriteMessage msg)
+        private NetSendResult ForwardToLidgren(IWriteMessage msg, DeliveryMethod deliveryMethod)
        {
-            NetOutgoingMessage lidgrenMsg = netClient.CreateMessage();
-            lidgrenMsg.Write(msg.Buffer, 0, msg.LengthBytes);
+            ToolBox.ThrowIfNull(netClient);

-            NetSendResult result = netClient.SendMessage(lidgrenMsg, NetDeliveryMethod.ReliableUnordered);
-            if (result != NetSendResult.Queued && result != NetSendResult.Sent)
-            {
-                DebugConsole.NewMessage("Failed to send message to host: " + result + "\n" + Environment.StackTrace);
-            }
+            return netClient.SendMessage(msg.ToLidgren(netClient), deliveryMethod.ToLidgren());
        }

 #if DEBUG
@@ -241,4 +274,4 @@ namespace Barotrauma.Networking
        }
 #endif
    }
-}
+}