[Milestone] AssemblyLoader completed.

Details: - Assembly Mgmt Service for loading now a separate interface, not intended for normal use. - Assembly Loader work; implemented custom dictionary key and table. - Assembly loading work. - EventService completed. - Moved assembly extensions to ModUtils.cs - Work to event service. NetworkService work - Added ImpromptuInterfaces package. - Networking Service work to support NetVars - Event Service - Added assemblies references package for script compilation. Updated Roslyn version for compatibility. - Package Loading work. Swap Harmony to HarmonyX - More refactor conversion to FluentResults. - Updated StylesService to return Results. - Refactor of PackageService partially complete. - Made IService.Reset() required to return a Result. - Moved plugin/assembly related code to their own folder (same namespace). - Updated interfaces to reflect the use of Result<T>. - Partial refactor, incomplete. - Added 'FluentResults' so we can stop using cursed Exception-based flow control in loading code. - Added 'OneOf' nuget package: https://github.com/mcintyre321/OneOf for the implementation of the Optional<T> pattern and complex discrete return types instead of cursed enums (see current AssemblyManager.cs). - Reapplied old branch changes.
2024-11-04 02:33:31 -05:00
parent 01cc1d331b
commit 6880e5e9ee
97 changed files with 4100 additions and 1512 deletions
@@ -0,0 +1,135 @@
+using Barotrauma.LuaCs.Services;
+using Barotrauma.Networking;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma.LuaCs.Networking;
+
+partial class NetworkingService
+{
+    private Dictionary<ushort, Queue<IReadMessage>> receiveQueue = new Dictionary<ushort, Queue<IReadMessage>>();
+
+    public void SendSyncMessage()
+    {
+        if (GameMain.Client == null) { return; }
+
+        WriteOnlyMessage message = new WriteOnlyMessage();
+        message.WriteByte((byte)ClientPacketHeader.LUA_NET_MESSAGE);
+        message.WriteByte((byte)LuaCsClientToServer.RequestAllIds);
+        GameMain.Client.ClientPeer.Send(message, DeliveryMethod.Reliable);
+    }
+
+    public void NetMessageReceived(IReadMessage netMessage, ServerPacketHeader header, Client client = null)
+    {
+        if (header != ServerPacketHeader.LUA_NET_MESSAGE)
+        {
+            return;
+        }
+
+        LuaCsServerToClient luaCsHeader = (LuaCsServerToClient)netMessage.ReadByte();
+
+        switch (luaCsHeader)
+        {
+            case LuaCsServerToClient.NetMessageString:
+                HandleNetMessageString(netMessage);
+                break;
+
+            case LuaCsServerToClient.NetMessageId:
+                HandleNetMessageId(netMessage);
+                break;
+
+            case LuaCsServerToClient.ReceiveIds:
+                ReadIds(netMessage);
+                break;
+        }
+    }
+
+    public INetWriteMessage Start(Guid netId)
+    {
+        var message = new WriteOnlyMessage();
+
+        message.WriteByte((byte)ClientPacketHeader.LUA_NET_MESSAGE);
+
+        if (idToPacket.ContainsKey(netId))
+        {
+            message.WriteByte((byte)LuaCsClientToServer.NetMessageId);
+            message.WriteUInt16(idToPacket[netId]);
+        }
+        else
+        {
+            message.WriteByte((byte)LuaCsClientToServer.NetMessageString);
+            message.WriteBytes(netId.ToByteArray(), 0, 16);
+        }
+
+        return message.ToNetWriteMessage();
+    }
+
+    public void RequestId(Guid netId)
+    {
+        if (idToPacket.ContainsKey(netId)) { return; }
+
+        if (GameMain.Client == null) { return; }
+
+        WriteOnlyMessage message = new WriteOnlyMessage();
+        message.WriteByte((byte)ClientPacketHeader.LUA_NET_MESSAGE);
+        message.WriteByte((byte)LuaCsClientToServer.RequestSingleId);
+
+        message.WriteBytes(netId.ToByteArray(), 0, 16);
+
+        Send(message, DeliveryMethod.Reliable);
+    }
+
+    public void Send(IWriteMessage netMessage, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
+    {
+        GameMain.Client.ClientPeer.Send(netMessage, deliveryMethod);
+    }
+
+    private void HandleNetMessageId(IReadMessage netMessage, Client client = null)
+    {
+        ushort id = netMessage.ReadUInt16();
+
+        if (packetToId.ContainsKey(id))
+        {
+            HandleNetMessage(netMessage, packetToId[id], client);
+        }
+        else
+        {
+            if (!receiveQueue.ContainsKey(id)) { receiveQueue[id] = new Queue<IReadMessage>(); }
+            receiveQueue[id].Enqueue(netMessage);
+
+            if (GameSettings.CurrentConfig.VerboseLogging)
+            {
+                LuaCsLogger.LogMessage($"Received NetMessage with unknown id {id} from server, storing in queue in case we receive the id later.");
+            }
+        }
+    }
+
+    private void ReadIds(IReadMessage netMessage)
+    {
+        ushort size = netMessage.ReadUInt16();
+
+        for (int i = 0; i < size; i++)
+        {
+            ushort packetId = netMessage.ReadUInt16();
+            Guid netId = new Guid(netMessage.ReadBytes(16));
+
+            packetToId[packetId] = netId;
+            idToPacket[netId] = packetId;
+
+            if (!receiveQueue.ContainsKey(packetId))
+            {
+                continue;
+            }
+
+            // We could have received messages before receiving the sync message, so we need to process them now
+
+            while (receiveQueue[packetId].TryDequeue(out var queueMessage))
+            {
+                if (netReceives.ContainsKey(netId))
+                {
+                    netReceives[netId](queueMessage);
+                }
+            }
+        }
+    }
+}