Upgrade LiteNetLib to v1.0.1.1 (#2023)

* Upgrade LiteNetLib to v0.9.5.2

* Upgrade to LiteNetLib 1.0.1.1

* QoL

* Replace WrapperPacket for direct byte sending

* Added extra NR checking in WorldPersistence

* Using bitwise operation in NitroxConnectionStateExtensions

Author: Jannify

Nitrox.Test/Client/Communication/DeferredPacketReceiverTest.cs

@@ -43,7 +43,7 @@ public void TestInitialize()
         public void NonActionPacket()
         {
             TestNonActionPacket packet = new TestNonActionPacket(PLAYER_ID);
-            packetReceiver.PacketReceived(packet, 0);
+            packetReceiver.PacketReceived(packet);
 
             Queue<Packet> packets = packetReceiver.GetReceivedPackets();
 

Nitrox.sln.DotSettings

@@ -103,6 +103,7 @@
 	<s:Boolean x:Key="/Default/CodeStyle/Naming/CSharpNaming/ApplyAutoDetectedRules/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=Constants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=EnumMember/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=LocalConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=Parameters/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;ExtraRule Prefix="__" Suffix="" Style="aaBb" /&gt;&lt;ExtraRule Prefix="___" Suffix="" Style="aaBb" /&gt;&lt;ExtraRule Prefix="____" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>

NitroxClient/Communication/Abstract/IClient.cs

@@ -13,6 +13,7 @@ public interface IClient
         bool IsConnected { get; }
         Task StartAsync(string ipAddress, int serverPort);
         void Stop();
+        void PollEvents();
         void Send(Packet packet);
     }
 }

NitroxClient/Communication/LANBroadcastClient.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using LiteNetLib;
+using LiteNetLib.Utils;
+using NitroxModel.Constants;
+
+namespace NitroxClient.Communication;
+
+public static class LANBroadcastClient
+{
+    private static event Action<IPEndPoint> serverFound;
+    public static event Action<IPEndPoint> ServerFound
+    {
+        add
+        {
+            serverFound += value;
+
+            // Trigger event for servers already found.
+            foreach (IPEndPoint server in discoveredServers)
+            {
+                value?.Invoke(server);
+            }
+        }
+        remove => serverFound -= value;
+    }
+    private static Task<IEnumerable<IPEndPoint>> lastTask;
+    private static ConcurrentBag<IPEndPoint> discoveredServers = new();
+
+    public static async Task<IEnumerable<IPEndPoint>> SearchAsync(bool force = false, CancellationToken cancellationToken = default)
+    {
+        if (!force && lastTask != null)
+        {
+            return await lastTask;
+        }
+
+        discoveredServers = new ConcurrentBag<IPEndPoint>();
+        return await (lastTask = SearchInternalAsync(cancellationToken));
+    }
+
+    private static async Task<IEnumerable<IPEndPoint>> SearchInternalAsync(CancellationToken cancellationToken = default)
+    {
+        static void ReceivedResponse(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
+        {
+            if (messageType != UnconnectedMessageType.Broadcast)
+            {
+                return;
+            }
+            string responseString = reader.GetString();
+            if (responseString != LANDiscoveryConstants.BROADCAST_RESPONSE_STRING)
+            {
+                return;
+            }
+            int serverPort = reader.GetInt();
+            IPEndPoint serverEndPoint = new(remoteEndPoint.Address, serverPort);
+            if (discoveredServers.Contains(serverEndPoint))
+            {
+                return;
+            }
+            
+            Log.Info($"Found LAN server at {serverEndPoint}.");
+            discoveredServers.Add(serverEndPoint);
+            OnServerFound(serverEndPoint);
+        }
+
+        cancellationToken = cancellationToken == default ? new CancellationTokenSource(TimeSpan.FromMinutes(1)).Token : cancellationToken;
+        EventBasedNetListener listener = new();
+        NetManager client = new(listener) { 
+            AutoRecycle = true, 
+            BroadcastReceiveEnabled = true,
+            UnconnectedMessagesEnabled = true
+        };
+        // Try start client on an available, predefined, port
+        foreach (int port in LANDiscoveryConstants.BROADCAST_PORTS)
+        {
+            if (client.Start(port))
+            {
+                break;
+            }
+        }
+        if (!client.IsRunning)
+        {
+            Log.Warn("Failed to start LAN discover client: none of the defined ports are available");
+            return Enumerable.Empty<IPEndPoint>();
+        }
+
+        Log.Info("Searching for LAN servers...");
+        listener.NetworkReceiveUnconnectedEvent += ReceivedResponse;
+        Task broadcastTask = Task.Run(async () =>
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                NetDataWriter writer = new();
+                writer.Put(LANDiscoveryConstants.BROADCAST_REQUEST_STRING);
+                foreach (int port in LANDiscoveryConstants.BROADCAST_PORTS)
+                {
+                    client.SendBroadcast(writer, port);
+                }
+                try
+                {
+                    await Task.Delay(5000, cancellationToken);
+                }
+                catch (TaskCanceledException)
+                {
+                    // ignore
+                }
+            }
+        }, cancellationToken);
+        Task receiveTask = Task.Run(async () =>
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                client.PollEvents();
+                try
+                {
+                    await Task.Delay(100, cancellationToken);
+                }
+                catch (TaskCanceledException)
+                {
+                    // ignore
+                }
+            }
+        }, cancellationToken);
+
+        await Task.WhenAll(broadcastTask, receiveTask);
+        // Cleanup
+        listener.ClearNetworkReceiveUnconnectedEvent();
+        client.Stop();
+        listener.NetworkReceiveUnconnectedEvent -= ReceivedResponse;
+        return discoveredServers;
+    }
+
+    private static void OnServerFound(IPEndPoint obj)
+    {
+        serverFound?.Invoke(obj);
+    }
+}