vlad.os/LuaCsForBarotraumaEP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Working NetworkingService without net vars

Browse Source
This commit is contained in:
Evil Factory
2026-02-07 18:22:19 -03:00
committed by Maplewheels
parent 87dc9be10e
commit ba10d9d031
15 changed files with 226 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Barotrauma/BarotraumaClient/ClientSource/LuaCs/Services/Compatibility/ILuaCsNetworking.cs
View File

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

8
Barotrauma/BarotraumaClient/ClientSource/LuaCs/Services/INetworkingService.cs
View File

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

63
Barotrauma/BarotraumaClient/ClientSource/LuaCs/Services/NetworkingService.cs
View File

@@ -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; }
WriteOnlyMessage message = new WriteOnlyMessage();
message.WriteByte((byte)ClientPacketHeader.LUA_NET_MESSAGE);
message.WriteByte((byte)LuaCsClientToServer.RequestAllIds);
GameMain.Client.ClientPeer.Send(message, DeliveryMethod.Reliable);
SendSyncMessage();
}
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.WriteBytes(netId.ToByteArray(), 0, 16);
message.WriteByte((byte)ClientToServer.NetMessageNetId);
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);
}
public void Send(IWriteMessage netMessage, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
{
GameMain.Client.ClientPeer.Send(netMessage, deliveryMethod);
SendToServer(message, DeliveryMethod.Reliable);
}
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;

3
Barotrauma/BarotraumaClient/ClientSource/Networking/GameClient.cs
View File

@@ -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 (

9
Barotrauma/BarotraumaServer/ServerSource/LuaCs/Services/INetworkingService.cs
View File

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

60
Barotrauma/BarotraumaServer/ServerSource/LuaCs/Services/NetworkingService.cs
View File

@@ -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.WriteBytes(netId.ToByteArray(), 0, 16);
message.WriteByte((byte)ServerToClient.NetMessageNetId);
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 Send(IWriteMessage netMessage, NetworkConnection connection = null, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
public void SendToClient(IWriteMessage netMessage, NetworkConnection connection = null, DeliveryMethod deliveryMethod = DeliveryMethod.Reliable)
{
if (connection == null)
{

11
Barotrauma/BarotraumaServer/ServerSource/Networking/GameServer.cs
View File

@@ -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)
{

2
Barotrauma/BarotraumaShared/SharedSource/LuaCs/Compatibility/ILuaCsNetworking.cs
View File

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

18
Barotrauma/BarotraumaShared/SharedSource/LuaCs/IEvents.cs
View File

@@ -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

17
Barotrauma/BarotraumaShared/SharedSource/LuaCs/LuaCsSetup.cs
View File

@@ -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;
}

8
Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/LuaScriptManagementService.cs
View File

@@ -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)

124
Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/NetworkingService.cs
View File

@@ -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,
NetMessageString,
RequestSingleId,
RequestAllIds,
private readonly string _value;
public NetId(string netId)
{
_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,
NetMessageString,
ReceiveIds
NetMessageInternalId,
NetMessageNetId,
RequestSingleNetId,
RequestAllNetIds,
}
private Dictionary<Guid, INetworkSyncVar> netVars = new Dictionary<Guid, INetworkSyncVar>();
private Dictionary<Guid, NetMessageReceived> netReceives = new Dictionary<Guid, NetMessageReceived>();
private Dictionary<ushort, Guid> packetToId = new Dictionary<ushort, Guid>();
private Dictionary<Guid, ushort> idToPacket = new Dictionary<Guid, ushort>();
private enum ServerToClient
{
NetMessageInternalId,
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);
LuaCsLogger.HandleException(e, LuaCsMessageOrigin.CSharpMod);
_loggerService.LogResults(new ExceptionalError("Exception thrown inside NetMessageReceive({netId})", e));
}
}
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;
netReceives = new Dictionary<Guid, NetMessageReceived>();
packetToId = new Dictionary<ushort, Guid>();
idToPacket = new Dictionary<Guid, ushort>();
return FluentResults.Result.Ok();
}
public void Dispose()
{
IsDisposed = true;
#if CLIENT
_eventService.Subscribe<IEventConnectedToServer>(this);
_eventService.Subscribe<IEventServerRawNetMessageReceived>(this);
#elif SERVER
_eventService.Subscribe<IEventClientRawNetMessageReceived>(this);
#endif
}
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;
}
}

26
Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/_Interfaces/INetworkingService.cs
View File

@@ -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);
public void Receive(Guid netId, NetMessageReceived action);
IWriteMessage Start(string netId);
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);
public void RegisterNetVar(INetworkSyncVar netVar);
public void SendNetVar(INetworkSyncVar netVar);
Guid GetNetworkIdForInstance(INetworkSyncVar var);
void RegisterNetVar(INetworkSyncVar netVar);
void SendNetVar(INetworkSyncVar netVar);
}

3
Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/_Lua/DefaultLuaRegistrar.cs
View File

@@ -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");

16
Barotrauma/BarotraumaShared/SharedSource/LuaCs/_Services/_Lua/LuaClasses/LuaConverters.cs
View File

@@ -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 =>