Working NetworkingService without net vars

Barotrauma/BarotraumaClient/ClientSource/LuaCs/Services/Compatibility/ILuaCsNetworking.cs

@@ -1,8 +0,0 @@
-using Barotrauma.Networking;
-
-namespace Barotrauma.LuaCs.Compatibility;
-
-internal partial interface ILuaCsNetworking : ILuaCsShim
-{
-
-}

Barotrauma/BarotraumaClient/ClientSource/LuaCs/Services/INetworkingService.cs

@@ -1,8 +0,0 @@
-using Barotrauma.Networking;
-
-namespace Barotrauma.LuaCs;
-
-internal partial interface INetworkingService : IReusableService
-{
-    void NetMessageReceived(IReadMessage message, ServerPacketHeader header);
-}

Barotrauma/BarotraumaClient/ClientSource/LuaCs/Services/NetworkingService.cs

@@ -1,4 +1,5 @@
 using Barotrauma.LuaCs;
+using Barotrauma.LuaCs.Events;
 using Barotrauma.Networking;
 using System;
 using System.Collections.Concurrent;
@@ -6,51 +7,51 @@ using System.Collections.Generic;
 
 namespace Barotrauma.LuaCs;
 
-partial class NetworkingService : INetworkingService
+public partial class NetworkingService : INetworkingService, IEventConnectedToServer, IEventServerRawNetMessageReceived
 {
     private ConcurrentDictionary<ushort, ConcurrentQueue<IReadMessage>> receiveQueue = new();
 
-    public void SendSyncMessage()
+    public void OnConnectedToServer()
     {
-        if (GameMain.Client == null) { return; }
+        SendSyncMessage();
-
-        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)
+    public void OnReceivedServerNetMessage(IReadMessage netMessage, ServerPacketHeader serverPacketHeader)
     {
-        if (header != ServerPacketHeader.LUA_NET_MESSAGE)
+        if (serverPacketHeader != ServerPacketHeader.LUA_NET_MESSAGE)
         {
             return;
         }
 
-        LuaCsServerToClient luaCsHeader = (LuaCsServerToClient)netMessage.ReadByte();
+        ServerToClient luaCsHeader = (ServerToClient)netMessage.ReadByte();
 
         switch (luaCsHeader)
         {
-            case LuaCsServerToClient.NetMessageString:
+            case ServerToClient.NetMessageNetId:
                 HandleNetMessageString(netMessage);
                 break;
 
-            case LuaCsServerToClient.NetMessageId:
+            case ServerToClient.NetMessageInternalId:
                 HandleNetMessageId(netMessage);
                 break;
 
-            case LuaCsServerToClient.ReceiveIds:
+            case ServerToClient.ReceiveNetIds:
                 ReadIds(netMessage);
                 break;
         }
     }
 
-    public void NetMessageReceived(IReadMessage message, ServerPacketHeader header)
+    private void SendSyncMessage()
     {
-        throw new NotImplementedException();
+        if (GameMain.Client == null) { return; }
+
+        WriteOnlyMessage message = new WriteOnlyMessage();
+        message.WriteByte((byte)ClientPacketHeader.LUA_NET_MESSAGE);
+        message.WriteByte((byte)ClientToServer.RequestAllNetIds);
+        GameMain.Client.ClientPeer.Send(message, DeliveryMethod.Reliable);
     }
 
-    public IWriteMessage Start(Guid netId)
+    public IWriteMessage Start(NetId netId)
     {
         var message = new WriteOnlyMessage();
 
@@ -58,19 +59,24 @@ partial class NetworkingService : INetworkingService
 
         if (idToPacket.ContainsKey(netId))
         {
-            message.WriteByte((byte)LuaCsClientToServer.NetMessageId);
+            message.WriteByte((byte)ClientToServer.NetMessageInternalId);
             message.WriteUInt16(idToPacket[netId]);
         }
         else
         {
-            message.WriteByte((byte)LuaCsClientToServer.NetMessageString);
+            message.WriteByte((byte)ClientToServer.NetMessageNetId);
-            message.WriteBytes(netId.ToByteArray(), 0, 16);
+            NetId.Write(message, netId);
         }
 
         return message;
     }
 
-    public void RequestId(Guid netId)
+    public void SendToServer(IWriteMessage netMessage, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
+    {
+        GameMain.Client.ClientPeer.Send(netMessage, deliveryMethod);
+    }
+
+    private void RequestId(NetId netId)
     {
         if (idToPacket.ContainsKey(netId)) { return; }
 
@@ -78,16 +84,11 @@ partial class NetworkingService : INetworkingService
 
         WriteOnlyMessage message = new WriteOnlyMessage();
         message.WriteByte((byte)ClientPacketHeader.LUA_NET_MESSAGE);
-        message.WriteByte((byte)LuaCsClientToServer.RequestSingleId);
+        message.WriteByte((byte)ClientToServer.RequestSingleNetId);
 
-        message.WriteBytes(netId.ToByteArray(), 0, 16);
+        NetId.Write(message, netId);
 
-        Send(message, DeliveryMethod.Reliable);
+        SendToServer(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)
@@ -105,7 +106,7 @@ partial class NetworkingService : INetworkingService
 
             if (GameSettings.CurrentConfig.VerboseLogging)
             {
-                LuaCsLogger.LogMessage($"Received NetMessage with unknown id {id} from server, storing in queue in case we receive the id later.");
+                _loggerService.LogMessage($"Received NetMessage with unknown id {id} from server, storing in queue in case we receive the id later.");
             }
         }
     }
@@ -117,7 +118,7 @@ partial class NetworkingService : INetworkingService
         for (int i = 0; i < size; i++)
         {
             ushort packetId = netMessage.ReadUInt16();
-            Guid netId = new Guid(netMessage.ReadBytes(16));
+            NetId netId = NetId.Read(netMessage);
 
             packetToId[packetId] = netId;
             idToPacket[netId] = packetId;

Barotrauma/BarotraumaClient/ClientSource/Networking/GameClient.cs

@@ -1,6 +1,7 @@
 using Barotrauma.Extensions;
 using Barotrauma.IO;
 using Barotrauma.Items.Components;
+using Barotrauma.LuaCs.Events;
 using Barotrauma.Steam;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Input;
@@ -603,7 +604,7 @@ namespace Barotrauma.Networking
         {
             ServerPacketHeader header = (ServerPacketHeader)inc.ReadByte();
 
-            GameMain.LuaCs.NetworkingService.NetMessageReceived(inc, header);
+            GameMain.LuaCs.EventService.PublishEvent<IEventServerRawNetMessageReceived>(p => p.OnReceivedServerNetMessage(inc, header));
 
             if (roundInitStatus == RoundInitStatus.WaitingForStartGameFinalize
                 && header is not (

Barotrauma/BarotraumaServer/ServerSource/LuaCs/Services/INetworkingService.cs

@@ -1,9 +0,0 @@
-
-using Barotrauma.Networking;
-
-namespace Barotrauma.LuaCs;
-
-internal partial interface INetworkingService : IReusableService
-{
-    void NetMessageReceived(IReadMessage message, ClientPacketHeader header, Client client);
-}

Barotrauma/BarotraumaServer/ServerSource/LuaCs/Services/NetworkingService.cs

@@ -1,4 +1,4 @@
-using Barotrauma.LuaCs;
+using Barotrauma.LuaCs.Events;
 using Barotrauma.Networking;
 using System;
 using System.Collections.Generic;
@@ -7,7 +7,7 @@ using System.Linq;
 // ReSharper disable once CheckNamespace
 namespace Barotrauma.LuaCs;
 
-partial class NetworkingService : INetworkingService
+partial class NetworkingService : INetworkingService, IEventClientRawNetMessageReceived
 {
     private const int MaxRegisterPerClient = 1000;
 
@@ -15,7 +15,7 @@ partial class NetworkingService : INetworkingService
 
     private ushort currentId = 0;
 
-    public IWriteMessage Start(Guid netId)
+    public IWriteMessage Start(NetId netId)
     {
         var message = new WriteOnlyMessage();
 
@@ -23,42 +23,44 @@ partial class NetworkingService : INetworkingService
 
         if (idToPacket.ContainsKey(netId))
         {
-            message.WriteByte((byte)LuaCsServerToClient.NetMessageId);
+            message.WriteByte((byte)ServerToClient.NetMessageInternalId);
             message.WriteUInt16(idToPacket[netId]);
         }
         else
         {
-            message.WriteByte((byte)LuaCsServerToClient.NetMessageString);
+            message.WriteByte((byte)ServerToClient.NetMessageNetId);
-            message.WriteBytes(netId.ToByteArray(), 0, 16);
+            NetId.Write(message, netId);
         }
 
         return message;
     }
 
-    public void NetMessageReceived(IReadMessage netMessage, ClientPacketHeader header, Client client = null)
+    public void OnReceivedClientNetMessage(IReadMessage netMessage, ClientPacketHeader serverPacketHeader, NetworkConnection sender)
     {
-        if (header != ClientPacketHeader.LUA_NET_MESSAGE)
+        if (serverPacketHeader != ClientPacketHeader.LUA_NET_MESSAGE)
         {
             return;
         }
 
-        LuaCsClientToServer luaCsHeader = (LuaCsClientToServer)netMessage.ReadByte();
+        Client client = GameMain.Server.ConnectedClients.First(c => c.Connection == sender);
+
+        ClientToServer luaCsHeader = (ClientToServer)netMessage.ReadByte();
 
         switch (luaCsHeader)
         {
-            case LuaCsClientToServer.NetMessageString:
+            case ClientToServer.NetMessageNetId:
                 HandleNetMessageString(netMessage, client);
                 break;
 
-            case LuaCsClientToServer.NetMessageId:
+            case ClientToServer.NetMessageInternalId:
                 HandleNetMessageId(netMessage, client);
                 break;
 
-            case LuaCsClientToServer.RequestAllIds:
+            case ClientToServer.RequestAllNetIds:
                 WriteAllIds(client);
                 break;
 
-            case LuaCsClientToServer.RequestSingleId:
+            case ClientToServer.RequestSingleNetId:
                 RequestIdSingle(netMessage, client);
                 break;
         }
@@ -70,7 +72,7 @@ partial class NetworkingService : INetworkingService
 
         if (packetToId.ContainsKey(id))
         {
-            Guid netId = packetToId[id];
+            NetId netId = packetToId[id];
 
             HandleNetMessage(netMessage, netId, client);
         }
@@ -78,12 +80,12 @@ partial class NetworkingService : INetworkingService
         {
             if (GameSettings.CurrentConfig.VerboseLogging)
             {
-                LuaCsLogger.LogError($"Received NetMessage for unknown id {id} from {GameServer.ClientLogName(client)}.");
+                _loggerService.LogError($"Received NetMessage for unknown id {id} from {GameServer.ClientLogName(client)}.");
             }
         }
     }
 
-    private ushort RegisterId(Guid netId)
+    private ushort RegisterId(NetId netId)
     {
         if (idToPacket.ContainsKey(netId))
         {
@@ -92,7 +94,7 @@ partial class NetworkingService : INetworkingService
 
         if (currentId >= ushort.MaxValue)
         {
-            LuaCsLogger.LogError($"Tried to register more than {ushort.MaxValue} network ids!");
+            _loggerService.LogError($"Tried to register more than {ushort.MaxValue} network ids!");
             return 0;
         }
 
@@ -108,7 +110,7 @@ partial class NetworkingService : INetworkingService
 
     private void RequestIdSingle(IReadMessage netMessage, Client client)
     {
-        Guid netId = new Guid(netMessage.ReadBytes(16));
+        NetId netId = NetId.Read(netMessage);
 
         if (!idToPacket.ContainsKey(netId) && client.AccountId.TryUnwrap(out AccountId id))
         {
@@ -121,7 +123,7 @@ partial class NetworkingService : INetworkingService
 
             if (clientRegisterCount[id.StringRepresentation] > MaxRegisterPerClient)
             {
-                LuaCsLogger.Log($"{GameServer.ClientLogName(client)} Tried to register more than {MaxRegisterPerClient} Ids!");
+                _loggerService.Log($"{GameServer.ClientLogName(client)} Tried to register more than {MaxRegisterPerClient} Ids!");
                 return;
             }
         }
@@ -129,38 +131,36 @@ partial class NetworkingService : INetworkingService
         RegisterId(netId);
     }
 
-    private void WriteIdToAll(ushort packet, Guid netId)
+    private void WriteIdToAll(ushort packet, NetId netId)
     {
         WriteOnlyMessage message = new WriteOnlyMessage();
         message.WriteByte((byte)ServerPacketHeader.LUA_NET_MESSAGE);
-        message.WriteByte((byte)LuaCsServerToClient.ReceiveIds);
+        message.WriteByte((byte)ServerToClient.ReceiveNetIds);
 
         message.WriteUInt16(1);
         message.WriteUInt16(packet);
-        message.WriteBytes(netId.ToByteArray(), 0, 16);
+        NetId.Write(message, netId);
 
-        Send(message, null, DeliveryMethod.Reliable);
+        SendToClient(message, null, DeliveryMethod.Reliable);
     }
 
     private void WriteAllIds(Client client)
     {
         WriteOnlyMessage message = new WriteOnlyMessage();
         message.WriteByte((byte)ServerPacketHeader.LUA_NET_MESSAGE);
-        message.WriteByte((byte)LuaCsServerToClient.ReceiveIds);
+        message.WriteByte((byte)ServerToClient.ReceiveNetIds);
 
         message.WriteUInt16((ushort)packetToId.Count());
-        foreach ((ushort packet, Guid netId) in packetToId)
+        foreach ((ushort packet, NetId netId) in packetToId)
         {
             message.WriteUInt16(packet);
-            message.WriteBytes(netId.ToByteArray(), 0, 16);
+            NetId.Write(message, netId);
         }
 
-        Send(message, client.Connection, DeliveryMethod.Reliable);
+        SendToClient(message, client.Connection, DeliveryMethod.Reliable);
     }
 
-    public void ClientWriteLobby(Client client) => GameMain.Server.ClientWriteLobby(client);
+    public void SendToClient(IWriteMessage netMessage, NetworkConnection connection = null, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
-
-    public void Send(IWriteMessage netMessage, NetworkConnection connection = null, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
     {
         if (connection == null)
         {

Barotrauma/BarotraumaServer/ServerSource/Networking/GameServer.cs

@@ -1,19 +1,20 @@
 using Barotrauma.Extensions;
 using Barotrauma.IO;
 using Barotrauma.Items.Components;
+using Barotrauma.LuaCs.Events;
+using Barotrauma.PerkBehaviors;
 using Barotrauma.Steam;
 using Lidgren.Network;
 using Microsoft.Xna.Framework;
+using MoonSharp.Interpreter;
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
+using System.Net;
 using System.Threading;
 using System.Xml.Linq;
-using MoonSharp.Interpreter;
-using System.Net;
-using Barotrauma.PerkBehaviors;
 
 namespace Barotrauma.Networking
 {
@@ -836,8 +837,8 @@ namespace Barotrauma.Networking
             using var _ = dosProtection.Start(connectedClient);
 
             ClientPacketHeader header = (ClientPacketHeader)inc.ReadByte();
-            
+
-            GameMain.LuaCs.NetworkingService.NetMessageReceived(inc, header, connectedClient);
+            GameMain.LuaCs.EventService.PublishEvent<IEventClientRawNetMessageReceived>(p => p.OnReceivedClientNetMessage(inc, header, sender));
 
             switch (header)
             {

Barotrauma/BarotraumaShared/SharedSource/LuaCs/Compatibility/ILuaCsNetworking.cs

@@ -1,6 +1,6 @@
 namespace Barotrauma.LuaCs.Compatibility;
 
-internal partial interface ILuaCsNetworking : ILuaCsShim
+public interface ILuaCsNetworking : ILuaCsShim
 {
     
 }

Barotrauma/BarotraumaShared/SharedSource/LuaCs/IEvents.cs

@@ -121,6 +121,24 @@ public interface IEventDrawUpdate : IEvent<IEventDrawUpdate>
     }.ActLike<IEventDrawUpdate>();
 }
 
+#if CLIENT
+public interface IEventServerRawNetMessageReceived : IEvent<IEventServerRawNetMessageReceived>
+{
+    void OnReceivedServerNetMessage(IReadMessage netMessage, ServerPacketHeader serverPacketHeader);
+}
+
+public interface IEventConnectedToServer : IEvent<IEventConnectedToServer>
+{
+    void OnConnectedToServer();
+}
+
+#elif SERVER
+public interface IEventClientRawNetMessageReceived : IEvent<IEventClientRawNetMessageReceived>
+{
+    void OnReceivedClientNetMessage(IReadMessage netMessage, ClientPacketHeader serverPacketHeader, NetworkConnection sender);
+}
+#endif
+
 #endregion
 
 #region Networking

Barotrauma/BarotraumaShared/SharedSource/LuaCs/LuaCsSetup.cs

@@ -184,7 +184,7 @@ namespace Barotrauma
             servicesProvider.RegisterServiceResolver<IPluginManagementService>(factory => factory.GetInstance<IAssemblyManagementService>());
             servicesProvider.RegisterServiceType<ILuaScriptManagementService, LuaScriptManagementService>(ServiceLifetime.Singleton);
             servicesProvider.RegisterServiceType<IConfigService, ConfigService>(ServiceLifetime.Singleton);
-            // TODO: INetworkingService
+            servicesProvider.RegisterServiceType<INetworkingService, NetworkingService>(ServiceLifetime.Singleton);
 
             // Extension/Sub Services
             servicesProvider.RegisterServiceType<IAssemblyLoaderService.IFactory, AssemblyLoader.Factory>(ServiceLifetime.Transient);
@@ -296,10 +296,11 @@ namespace Barotrauma
                     Logger.LogResults(PackageManagementService.UnloadAllPackages());
                 }
 
+                EventService.Reset();
                 ConfigService.Reset();
                 LuaScriptManagementService.Reset();
                 PackageManagementService.Reset();
-                EventService.Reset();
+                NetworkingService.Reset();
 
                 SubscribeToLuaCsEvents();
 
@@ -343,10 +344,18 @@ namespace Barotrauma
 #if DEBUG
                     Logger.LogResults(PackageManagementService.ExecuteLoadedPackages(ContentPackageManager.EnabledPackages.All.ToImmutableArray(), true));
 #else
-                     Logger.LogResults(PackageManagementService.ExecuteLoadedPackages(ContentPackageManager.EnabledPackages.All.ToImmutableArray(), IsCsEnabled));
+                    Logger.LogResults(PackageManagementService.ExecuteLoadedPackages(ContentPackageManager.EnabledPackages.All.ToImmutableArray(), IsCsEnabled));
 #endif
                 }
-                
+
+#if CLIENT
+                // Technically not very accurate, but we want to call after we run mods anyway
+                if (GameMain.Client != null)
+                {
+                    EventService.PublishEvent<IEventConnectedToServer>(static p => p.OnConnectedToServer());
+                }
+#endif
+
                 CurrentRunState = RunState.Running;
             }
                 

Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/LuaScriptManagementService.cs

@@ -47,7 +47,7 @@ class LuaScriptManagementService : ILuaScriptManagementService, ILuaDataService
     private readonly ILuaCsTimer _luaCsTimer;
     private readonly IDefaultLuaRegistrar _defaultLuaRegistrar;
     private readonly IPluginManagementService _pluginManagementService;
-    //private readonly ILuaCsNetworking _luaCsNetworking;
+    private readonly INetworkingService _networkingService;
     //private readonly ILuaCsUtility _luaCsUtility;
 
     public LuaScriptManagementService(
@@ -58,9 +58,9 @@ class LuaScriptManagementService : ILuaScriptManagementService, ILuaDataService
         IDefaultLuaRegistrar defaultLuaRegistrar,
         ILuaScriptServicesConfig luaScriptServicesConfig,
         IPluginManagementService pluginManagementService,
+        INetworkingService networkingService,
         LuaGame luaGame,
         IEventService eventService,
-        //ILuaCsNetworking luaCsNetworking,
         //ILuaCsUtility luaCsUtility,
         ILuaCsTimer luaCsTimer
         )
@@ -72,6 +72,7 @@ class LuaScriptManagementService : ILuaScriptManagementService, ILuaDataService
         _luaScriptServicesConfig = luaScriptServicesConfig;
         _loggerService = loggerService;
         _pluginManagementService = pluginManagementService;
+        _networkingService = networkingService;
 
         _luaGame = luaGame;
         _eventService = eventService;
@@ -192,6 +193,7 @@ class LuaScriptManagementService : ILuaScriptManagementService, ILuaDataService
         UserData.RegisterType(typeof(ILuaScriptResourceInfo));
         UserData.RegisterType(typeof(IResourceInfo));
         UserData.RegisterType(typeof(IUserDataDescriptor));
+        UserData.RegisterType(typeof(INetworkingService));
 
         new LuaConverters(_script).RegisterLuaConverters();
 
@@ -211,7 +213,7 @@ class LuaScriptManagementService : ILuaScriptManagementService, ILuaDataService
         _script.Globals["Hook"] = _eventService;
         _script.Globals["Timer"] = _luaCsTimer;
         _script.Globals["File"] = UserData.CreateStatic<LuaCsFile>();
-        //_script.Globals["Networking"] = _luaCsNetworking;
+        _script.Globals["Networking"] = _networkingService;
         //_script.Globals["Steam"] = Steam;
 
         if (GameMain.LuaCs.IsCsEnabled)

Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/NetworkingService.cs

@@ -1,52 +1,88 @@
 using Barotrauma.LuaCs;
+using Barotrauma.LuaCs.Compatibility;
+using Barotrauma.LuaCs.Events;
 using Barotrauma.Networking;
+using FluentResults;
 using System;
 using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Text;
 
 namespace Barotrauma.LuaCs;
 
-internal partial class NetworkingService : INetworkingService
+public partial class NetworkingService : INetworkingService
 {
-    private enum LuaCsClientToServer
+    public readonly record struct NetId
     {
-        NetMessageId,
+        private readonly string _value;
-        NetMessageString,
+
-        RequestSingleId,
+        public NetId(string netId)
-        RequestAllIds,
+        {
+            _value = netId;
+        }
+
+        public static void Write(IWriteMessage message, NetId netId)
+        {
+            message.WriteString(netId._value);
+        }
+
+        public static NetId Read(IReadMessage message)
+        {
+            return new NetId(message.ReadString());
+        }
     }
 
-    private enum LuaCsServerToClient
+    private enum ClientToServer
     {
-        NetMessageId,
+        NetMessageInternalId,
-        NetMessageString,
+        NetMessageNetId,
-        ReceiveIds
+        RequestSingleNetId,
+        RequestAllNetIds,
     }
 
-    private Dictionary<Guid, INetworkSyncVar> netVars = new Dictionary<Guid, INetworkSyncVar>();
+    private enum ServerToClient
-    private Dictionary<Guid, NetMessageReceived> netReceives = new Dictionary<Guid, NetMessageReceived>();
+    {
-    private Dictionary<ushort, Guid> packetToId = new Dictionary<ushort, Guid>();
+        NetMessageInternalId,
-    private Dictionary<Guid, ushort> idToPacket = new Dictionary<Guid, ushort>();
+        NetMessageNetId,
+        ReceiveNetIds
+    }
+
+    private Dictionary<NetId, NetMessageReceived> netReceives = new Dictionary<NetId, NetMessageReceived>();
+    private Dictionary<ushort, NetId> packetToId = new Dictionary<ushort, NetId>();
+    private Dictionary<NetId, ushort> idToPacket = new Dictionary<NetId, ushort>();
 
     public bool IsActive
     {
         get
         {
-            return GameMain.NetworkMember != null; // ehh?
+            return GameMain.NetworkMember != null;
         }
     }
+
     public bool IsSynchronized { get; private set; }
     public bool IsDisposed { get; private set; }
 
-    public void Initialize()
+    private readonly IEventService _eventService;
+    private readonly ILoggerService _loggerService;
+
+    public NetworkingService(IEventService eventService, ILoggerService loggerService)
     {
+        _eventService = eventService;
+        _loggerService = loggerService;
+
 #if SERVER
         IsSynchronized = true;
-#elif CLIENT
-        SendSyncMessage();
 #endif
+
+        SubscribeToEvents();
     }
 
-    public void Receive(Guid netId, NetMessageReceived callback)
+    public void Receive(string netIdString, NetMessageReceived callback) => Receive(new NetId(netIdString), callback);
+    public void Receive(Guid netIdGuid, NetMessageReceived callback) => Receive(new NetId(netIdGuid.ToString()), callback);
+    public IWriteMessage Start(string netIdString) => Start(new NetId(netIdString));
+    public IWriteMessage Start(Guid netIdGuid) => Start(new NetId(netIdGuid.ToString()));
+
+    public void Receive(NetId netId, NetMessageReceived callback)
     {
 #if SERVER
         RegisterId(netId);
@@ -56,18 +92,21 @@ internal partial class NetworkingService : INetworkingService
         netReceives[netId] = callback;
     }
 
-    private void HandleNetMessage(IReadMessage netMessage, Guid netId, Client client = null)
+    private void HandleNetMessage(IReadMessage netMessage, NetId netId, Client client = null)
     {
         if (netReceives.ContainsKey(netId))
         {
             try
             {
+#if CLIENT
                 netReceives[netId](netMessage);
+#elif SERVER
+                netReceives[netId](netMessage, client.Connection);
+#endif
             }
             catch (Exception e)
             {
-                LuaCsLogger.LogError($"Exception thrown inside NetMessageReceive({netId})", LuaCsMessageOrigin.CSharpMod);
+                _loggerService.LogResults(new ExceptionalError("Exception thrown inside NetMessageReceive({netId})", e));
-                LuaCsLogger.HandleException(e, LuaCsMessageOrigin.CSharpMod);
             }
         }
         else
@@ -75,9 +114,9 @@ internal partial class NetworkingService : INetworkingService
             if (GameSettings.CurrentConfig.VerboseLogging)
             {
 #if SERVER
-                LuaCsLogger.LogError($"Received NetMessage for unknown netid {netId} from {GameServer.ClientLogName(client)}.");
+                _loggerService.LogError($"Received NetMessage for unknown netid {netId} from {GameServer.ClientLogName(client)}.");
 #else
-                LuaCsLogger.LogError($"Received NetMessage for unknown netid {netId} from server.");
+                _loggerService.LogError($"Received NetMessage for unknown netid {netId} from server.");
 #endif
             }
         }
@@ -85,23 +124,19 @@ internal partial class NetworkingService : INetworkingService
 
     private void HandleNetMessageString(IReadMessage netMessage, Client client = null)
     {
-        Guid guid = new Guid(netMessage.ReadBytes(16));
+        NetId netId = NetId.Read(netMessage);
 
-        HandleNetMessage(netMessage, guid, client);
+        HandleNetMessage(netMessage, netId, client);
     }
 
-    public FluentResults.Result Reset()
+    private void SubscribeToEvents()
     {
-        IsSynchronized = false;
+#if CLIENT
-        netReceives = new Dictionary<Guid, NetMessageReceived>();
+        _eventService.Subscribe<IEventConnectedToServer>(this);
-        packetToId = new Dictionary<ushort, Guid>();
+        _eventService.Subscribe<IEventServerRawNetMessageReceived>(this);
-        idToPacket = new Dictionary<Guid, ushort>();
+#elif SERVER
-        return FluentResults.Result.Ok();
+        _eventService.Subscribe<IEventClientRawNetMessageReceived>(this);
-    }
+#endif
-
-    public void Dispose()
-    {
-        IsDisposed = true;
     }
 
     public Guid GetNetworkIdForInstance(INetworkSyncVar var)
@@ -118,4 +153,19 @@ internal partial class NetworkingService : INetworkingService
     {
         throw new NotImplementedException();
     }
+
+    public FluentResults.Result Reset()
+    {
+        IsSynchronized = false;
+        netReceives = new Dictionary<NetId, NetMessageReceived>();
+        packetToId = new Dictionary<ushort, NetId>();
+        idToPacket = new Dictionary<NetId, ushort>();
+        SubscribeToEvents();
+        return FluentResults.Result.Ok();
+    }
+
+    public void Dispose()
+    {
+        IsDisposed = true;
+    }
 }

Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/_Interfaces/INetworkingService.cs

@@ -6,26 +6,32 @@ using Barotrauma.Networking;
 
 namespace Barotrauma.LuaCs;
 
-internal delegate void NetMessageReceived(IReadMessage netMessage);
+#if CLIENT
+public delegate void NetMessageReceived(IReadMessage netMessage);
+#elif SERVER
+public delegate void NetMessageReceived(IReadMessage netMessage, NetworkConnection connection);
+#endif
 
-internal partial interface INetworkingService : IReusableService, ILuaCsNetworking, IEntityNetworkingService
+public interface INetworkingService : IReusableService, ILuaCsNetworking, IEntityNetworkingService
 {
     bool IsActive { get; }
     bool IsSynchronized { get; }
 
-    public IWriteMessage Start(Guid netId);
+    IWriteMessage Start(string netId);
-    public void Receive(Guid netId, NetMessageReceived action);
+    IWriteMessage Start(Guid netId);
+    void Receive(string netId, NetMessageReceived action);
+    void Receive(Guid netId, NetMessageReceived action);
 #if SERVER
-    public void Send(IWriteMessage netMessage, NetworkConnection connection = null, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable);
+    void SendToClient(IWriteMessage netMessage, NetworkConnection connection = null, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable);
 #elif CLIENT
-    public void Send(IWriteMessage netMessage, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable);
+    void SendToServer(IWriteMessage netMessage, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable);
 #endif
-    
+
 }
 
 public interface IEntityNetworkingService
 {
-    public Guid GetNetworkIdForInstance(INetworkSyncVar var);
+    Guid GetNetworkIdForInstance(INetworkSyncVar var);
-    public void RegisterNetVar(INetworkSyncVar netVar);
+    void RegisterNetVar(INetworkSyncVar netVar);
-    public void SendNetVar(INetworkSyncVar netVar);
+    void SendNetVar(INetworkSyncVar netVar);
 }

Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/_Lua/DefaultLuaRegistrar.cs

@@ -49,12 +49,9 @@ public class DefaultLuaRegistrar : IDefaultLuaRegistrar
                 continue;
             }
 
-            _loggerService.LogMessage($"Registered {type.FullName}");
-
             _userDataService.RegisterType(type.FullName);
         }
 
-
         _userDataService.RegisterType("Barotrauma.LuaSByte");
         _userDataService.RegisterType("Barotrauma.LuaByte");
         _userDataService.RegisterType("Barotrauma.LuaInt16");

Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/_Lua/LuaClasses/LuaConverters.cs

@@ -134,6 +134,22 @@ namespace Barotrauma
                 RegisterHandler(f => (GUITextBlock.ClickableArea.OnClickDelegate)(
                 (a1, a2) => Call(f, a1, a2)));
             }
+
+            Script.GlobalOptions.CustomConverters.SetScriptToClrCustomConversion(DataType.Function, typeof(NetMessageReceived), v => (NetMessageReceived)((arg1) =>
+            {
+                if (v.Function.OwnerScript == _script)
+                {
+                    Call(v.Function, arg1);
+                }
+            }));
+#elif SERVER
+            Script.GlobalOptions.CustomConverters.SetScriptToClrCustomConversion(DataType.Function, typeof(NetMessageReceived), v => (NetMessageReceived)((arg1, arg2) =>
+            {
+                if (v.Function.OwnerScript == _script)
+                {
+                    Call(v.Function, arg1, arg2);
+                }
+            }));
 #endif
 
             Script.GlobalOptions.CustomConverters.SetScriptToClrCustomConversion(DataType.Table, typeof(Pair<JobPrefab, int>), v =>