Unstable v0.19.5.0

2022-09-14 12:47:17 -03:00
parent 3f2c843247
commit 1fd2a51bbb
158 changed files with 5702 additions and 4813 deletions
@@ -7,7 +7,7 @@ namespace Barotrauma.Networking
        public abstract string StringRepresentation { get; }
        
        public static Option<AccountId> Parse(string str)
-            => ReflectionUtils.ParseDerived<AccountId>(str);
+            => ReflectionUtils.ParseDerived<AccountId, string>(str);

        public abstract override bool Equals(object? obj);

@@ -7,7 +7,7 @@ namespace Barotrauma.Networking
        public abstract string StringRepresentation { get; }

        public static Option<Address> Parse(string str)
-            => ReflectionUtils.ParseDerived<Address>(str);
+            => ReflectionUtils.ParseDerived<Address, string>(str);

        public abstract bool IsLocalHost { get; }

@@ -17,31 +17,27 @@ namespace Barotrauma.Networking

        public LidgrenAddress(IPAddress netAddress)
        {
-            NetAddress = netAddress;
+            if (IPAddress.IsLoopback(netAddress))
+            {
+                NetAddress = IPAddress.Loopback;
+            }
+            else
+            {
+                NetAddress = netAddress;
+            }
        }

        public new static Option<LidgrenAddress> Parse(string endpointStr)
        {
-            if (IPAddress.TryParse(endpointStr, out IPAddress? netEndpoint))
+            if (endpointStr.Equals("localhost", StringComparison.OrdinalIgnoreCase))
+            {
+                return Option<LidgrenAddress>.Some(new LidgrenAddress(IPAddress.Loopback));
+            }
+            else if (IPAddress.TryParse(endpointStr, out IPAddress? netEndpoint))
            {
                return Option<LidgrenAddress>.Some(new LidgrenAddress(netEndpoint!));
            }
-
-            try
-            {
-                var resolvedAddresses = Dns.GetHostAddresses(endpointStr);
-                return resolvedAddresses.Any()
-                    ? Option<LidgrenAddress>.Some(new LidgrenAddress(resolvedAddresses.First()))
-                    : Option<LidgrenAddress>.None();
-            }
-            catch (SocketException)
-            {
-                return Option<LidgrenAddress>.None();
-            }
-            catch (ArgumentOutOfRangeException)
-            {
-                return Option<LidgrenAddress>.None();
-            }
+            return Option<LidgrenAddress>.None();            
        }

        public override bool Equals(object? obj)
@@ -22,12 +22,21 @@ namespace Barotrauma.Networking
        public override string ToString() => StringRepresentation;

        public static Option<Endpoint> Parse(string str)
-            => ReflectionUtils.ParseDerived<Endpoint>(str);
+            => ReflectionUtils.ParseDerived<Endpoint, string>(str);

-        public static bool operator ==(Endpoint a, Endpoint b)
-            => a.Equals(b);
+        public static bool operator ==(Endpoint? a, Endpoint? b)
+        {
+            if (a is null)
+            {
+                return b is null;
+            }
+            else
+            {
+                return a.Equals(b);
+            }
+        }

-        public static bool operator !=(Endpoint a, Endpoint b)
+        public static bool operator !=(Endpoint? a, Endpoint? b)
            => !(a == b);
    }
 }
@@ -24,24 +24,23 @@ namespace Barotrauma.Networking

        public new static Option<LidgrenEndpoint> Parse(string endpointStr)
        {
-            if (IPEndPoint.TryParse(endpointStr, out IPEndPoint? netEndpoint))
-            {
-                return Option<LidgrenEndpoint>.Some(new LidgrenEndpoint(netEndpoint!));
-            }
-
+            string hostName = endpointStr;
+            int port = NetConfig.DefaultPort;
            if (endpointStr.Count(c => c == ':') == 1)
            {
                string[] split = endpointStr.Split(':');
-                string hostName = split[0];
-                if (LidgrenAddress.Parse(hostName).TryUnwrap(out var adr)
-                    && int.TryParse(split[1], out var port))
-                {
-                    return Option<LidgrenEndpoint>.Some(new LidgrenEndpoint(adr.NetAddress, port));
-                }
+                hostName = split[0];
+                port = int.TryParse(split[1], out var tmpPort) ? tmpPort : port;
            }
-
-            return LidgrenAddress.Parse(endpointStr)
-                .Select(adr => new LidgrenEndpoint(adr.NetAddress, NetConfig.DefaultPort));
+            
+            if (LidgrenAddress.Parse(hostName).TryUnwrap(out var adr))
+            {
+                return Option<LidgrenEndpoint>.Some(new LidgrenEndpoint(adr.NetAddress, port));
+            }
+            
+            return IPEndPoint.TryParse(endpointStr, out IPEndPoint? netEndpoint)
+                ? Option<LidgrenEndpoint>.Some(new LidgrenEndpoint(netEndpoint))
+                : Option<LidgrenEndpoint>.None();
        }

        public override bool Equals(object? obj)
@@ -1,8 +1,8 @@
 #nullable enable
-
 using System;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Text;

 namespace Barotrauma.Networking
 {
@@ -68,7 +68,7 @@ namespace Barotrauma.Networking
        public byte[] Buffer;
        public readonly int Length => Buffer.Length;

-        public readonly IReadMessage GetReadMessage() => new ReadWriteMessage(Buffer, 0, Length, copyBuf: false);
+        public readonly IReadMessage GetReadMessageUncompressed() => new ReadWriteMessage(Buffer, 0, Length, copyBuf: false);
        public readonly IReadMessage GetReadMessage(bool isCompressed, NetworkConnection conn) => new ReadOnlyMessage(Buffer, isCompressed, 0, Length, conn);
    }

@@ -86,9 +86,164 @@ namespace Barotrauma.Networking
    }

    [NetworkSerialize]
-    internal struct PeerDisconnectPacket : INetSerializableStruct
+    internal readonly struct PeerDisconnectPacket : INetSerializableStruct
    {
-        public string Message;
+        public readonly DisconnectReason DisconnectReason;
+
+        public readonly string AdditionalInformation;
+
+        private PeerDisconnectPacket(
+            DisconnectReason disconnectReason,
+            string additionalInformation = "")
+        {
+            DisconnectReason = disconnectReason;
+            AdditionalInformation = additionalInformation;
+        }
+
+        public LocalizedString ChatMessage(Client c)
+            => DisconnectReason switch
+            {
+                DisconnectReason.Disconnected => TextManager.GetWithVariable("ServerMessage.ClientLeftServer",
+                        "[client]", c.Name),
+                _ => TextManager.GetWithVariables("ChatMsg.DisconnectedWithReason",
+                        ("[client]", c.Name),
+                        ("[reason]", TextManager.Get($"ChatMsg.DisconnectReason.{DisconnectReason}")))
+            };
+
+        private LocalizedString msgWithReason
+            => TextManager.Get($"DisconnectReason.{DisconnectReason}")
+               + "\n\n"
+               + TextManager.Get("banreason") + " " + AdditionalInformation;
+
+        private LocalizedString serverMessage
+            => TextManager.Get($"ServerMessage.{DisconnectReason}");
+        
+        public LocalizedString PopupMessage
+            => DisconnectReason switch
+            {
+                DisconnectReason.Banned => msgWithReason,
+                DisconnectReason.Kicked => msgWithReason,
+                DisconnectReason.InvalidVersion => TextManager.GetWithVariables("DisconnectMessage.InvalidVersion",
+                    ("[version]", AdditionalInformation),
+                    ("[clientversion]", GameMain.Version.ToString())),
+                DisconnectReason.ExcessiveDesyncOldEvent => serverMessage,
+                DisconnectReason.ExcessiveDesyncRemovedEvent => serverMessage,
+                DisconnectReason.SyncTimeout => serverMessage,
+                _ => TextManager.Get($"DisconnectReason.{DisconnectReason}").Fallback(TextManager.Get("ConnectionLost"))
+            };
+
+        public LocalizedString ReconnectMessage
+            => PopupMessage + "\n\n" + TextManager.Get("ConnectionLostReconnecting");
+
+        public PlayerConnectionChangeType ConnectionChangeType
+            => DisconnectReason switch
+            {
+                DisconnectReason.Banned => PlayerConnectionChangeType.Banned,
+                DisconnectReason.Kicked => PlayerConnectionChangeType.Kicked,
+                _ => PlayerConnectionChangeType.Disconnected
+            };
+
+        public bool ShouldAttemptReconnect
+            => DisconnectReason
+                is DisconnectReason.ExcessiveDesyncOldEvent
+                or DisconnectReason.ExcessiveDesyncRemovedEvent
+                or DisconnectReason.Timeout
+                or DisconnectReason.SyncTimeout
+                or DisconnectReason.SteamP2PTimeOut;
+
+        public bool IsEventSyncError
+            => DisconnectReason
+                is DisconnectReason.ExcessiveDesyncOldEvent
+                or DisconnectReason.ExcessiveDesyncRemovedEvent
+                or DisconnectReason.SyncTimeout;
+
+        public bool ShouldCreateAnalyticsEvent
+            => DisconnectReason is not (
+                   DisconnectReason.Disconnected
+                   or DisconnectReason.Banned
+                   or DisconnectReason.Kicked
+                   or DisconnectReason.TooManyFailedLogins
+                   or DisconnectReason.InvalidVersion);
+
+        public bool ShouldShowMessage
+            => DisconnectReason is not DisconnectReason.Disconnected;
+
+        private const string lidgrenSeparator = ":hankey:";
+
+        /// <summary>
+        /// This exists because Lidgren is a piece of shit and
+        /// doesn't readily support sending anything other than
+        /// a string through a disconnect packet, so this thing
+        /// needs a sufficiently nasty string representation that
+        /// can be decoded with some certainty that it won't get
+        /// mangled by user input.
+        /// </summary>
+        public string ToLidgrenStringRepresentation()
+        {
+            static string strToBase64(string str)
+                => Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
+
+            return DisconnectReason
+                   + lidgrenSeparator
+                   + strToBase64(AdditionalInformation);
+        }
+
+        public static Option<PeerDisconnectPacket> FromLidgrenStringRepresentation(string str)
+        {
+            // Lidgren has some hardcoded disconnect strings that it uses
+            // when it detects that a connection has failed. We can handle
+            // timeouts, so let's look for strings related to that and return
+            // an appropriate PeerDisconnectPacket.
+            switch (str)
+            {
+                case Lidgren.Network.NetConnection.NoResponseMessage:
+                case "Connection timed out":
+                case "Reconnecting":
+                    return Option<PeerDisconnectPacket>.Some(WithReason(DisconnectReason.Timeout));
+            }
+            
+            static string base64ToStr(string base64)
+                => Encoding.UTF8.GetString(Convert.FromBase64String(base64));
+
+            string[] split = str.Split(lidgrenSeparator);
+            if (split.Length != 2) { return Option<PeerDisconnectPacket>.None(); }
+            if (!Enum.TryParse(split[0], out DisconnectReason disconnectReason)) { return Option<PeerDisconnectPacket>.None(); }
+            return Option<PeerDisconnectPacket>.Some(new PeerDisconnectPacket(disconnectReason, base64ToStr(split[1])));
+        }
+        
+        public static PeerDisconnectPacket Custom(string customMessage)
+            => new PeerDisconnectPacket(
+                DisconnectReason.Unknown,
+                customMessage);
+
+        public static PeerDisconnectPacket WithReason(DisconnectReason disconnectReason)
+            => new PeerDisconnectPacket(disconnectReason);
+        
+        public static PeerDisconnectPacket Kicked(string? msg)
+            => new PeerDisconnectPacket(DisconnectReason.Kicked, msg ?? "");
+
+        public static PeerDisconnectPacket Banned(string? msg)
+            => new PeerDisconnectPacket(DisconnectReason.Banned, msg ?? "");
+        
+        public static PeerDisconnectPacket InvalidVersion()
+            => new PeerDisconnectPacket(
+                DisconnectReason.InvalidVersion,
+                GameMain.Version.ToString());
+
+        public static PeerDisconnectPacket SteamP2PError(Steamworks.P2PSessionError error)
+            => new PeerDisconnectPacket(
+                DisconnectReason.SteamP2PError,
+                error.ToString());
+        
+        public static PeerDisconnectPacket SteamAuthError(Steamworks.BeginAuthResult error)
+            => new PeerDisconnectPacket(
+                DisconnectReason.SteamAuthenticationFailed,
+                $"{nameof(Steamworks.BeginAuthResult)}.{error}");
+        
+        public static PeerDisconnectPacket SteamAuthError(Steamworks.AuthResponse error)
+            => new PeerDisconnectPacket(
+                DisconnectReason.SteamAuthenticationFailed,
+                $"{nameof(Steamworks.AuthResponse)}.{error}");
    }

    // ReSharper disable MemberCanBePrivate.Global, FieldCanBeMadeReadOnly.Global, UnassignedField.Global
@@ -101,11 +256,14 @@ namespace Barotrauma.Networking
        public byte[] HashBytes = Array.Empty<byte>();

        [NetworkSerialize]
-        public ulong WorkshopId;
+        public string UgcId = "";

        [NetworkSerialize]
        public uint InstallTimeDiffInSeconds;

+        [NetworkSerialize]
+        public bool IsMandatory;
+
        private Md5Hash? cachedHash;
        private DateTime? cachedDateTime;

@@ -130,9 +288,12 @@ namespace Barotrauma.Networking
        {
            Name = contentPackage.Name;
            Hash = contentPackage.Hash;
-            WorkshopId = contentPackage.SteamWorkshopId;
+            UgcId = contentPackage.UgcId.TryUnwrap(out var ugcId)
+                ? ugcId.StringRepresentation
+                : "";
+            IsMandatory = !contentPackage.Files.All(f => f is SubmarineFile);
            InstallTimeDiffInSeconds =
-                contentPackage.InstallTime is { } installTime
+                contentPackage.InstallTime.TryUnwrap(out var installTime)
                    ? (uint)(installTime - referenceTime).TotalSeconds
                    : 0;
        }