private void OnConnectionStatusChanged(SteamNetConnectionStatusChangedCallback_t param)
{
ulong clientSteamID = param.m_info.m_identityRemote.GetSteamID64();
if (param.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_Connected)
{
Connected = true;
OnConnected.Invoke();
Debug.Log("Connection established.");
if (BufferedData.Count > 0)
{
Debug.Log($"{BufferedData.Count} received before connection was established. Processing now.");
{
foreach (Action a in BufferedData)
{
a();
}
}
}
}
else if (param.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_ClosedByPeer)
{
Connected = false;
OnDisconnected.Invoke();
Debug.Log("Disconnected.");
SteamNetworkingSockets.CloseConnection(param.m_hConn, 0, "Disconnected", false);
}
else
{
Debug.Log($"Connection state changed: {param.m_info.m_eState.ToString()}");
}
}
public void FlushData()
{
foreach (HSteamNetConnection conn in connToMirrorID.FirstTypes)
{
SteamNetworkingSockets.FlushMessagesOnConnection(conn);
}
}
static bool Prefix(ZSteamSocket __instance, Queue <byte[]> ___m_sendQueue, ref int ___m_totalSent, HSteamNetConnection ___m_con)
{
if (!__instance.IsConnected())
{
return(false);
}
while (___m_sendQueue.Count > 0)
{
byte[] source = ___m_sendQueue.Peek();
IntPtr num = Marshal.AllocHGlobal(source.Length);
Marshal.Copy(source, 0, num, source.Length);
// This was k_nSteamNetworkingSend_ReliableNoNagle before
EResult connection = SteamNetworkingSockets.SendMessageToConnection(___m_con, num, (uint)source.Length, Constants.k_nSteamNetworkingSend_Reliable, out long _);
Marshal.FreeHGlobal(num);
if (connection == EResult.k_EResultOK)
{
___m_totalSent += source.Length;
___m_sendQueue.Dequeue();
}
else
{
ZLog.Log("Failed to send data " + connection);
break;
}
}
return(false);
}
// Token: 0x06000986 RID: 2438 RVA: 0x00045F84 File Offset: 0x00044184
public void Close()
{
if (this.m_con != HSteamNetConnection.Invalid)
{
ZLog.Log("Closing socket " + this.GetEndPointString());
this.Flush();
ZLog.Log(" send queue size:" + this.m_sendQueue.Count);
Thread.Sleep(100);
CSteamID steamID = this.m_peerID.GetSteamID();
SteamNetworkingSockets.CloseConnection(this.m_con, 0, "", false);
SteamUser.EndAuthSession(steamID);
this.m_con = HSteamNetConnection.Invalid;
}
if (this.m_listenSocket != HSteamListenSocket.Invalid)
{
ZLog.Log("Stopping listening socket");
SteamNetworkingSockets.CloseListenSocket(this.m_listenSocket);
this.m_listenSocket = HSteamListenSocket.Invalid;
}
if (ZSteamSocket.m_hostSocket == this)
{
ZSteamSocket.m_hostSocket = null;
}
this.m_peerID.Clear();
}
public ConnectionManager JoinSession(string ip, string port)
{
Client = SteamNetworkingSockets.ConnectNormal <MaydayClient>(NetAddress.From(ip, ushort.Parse(port)));
((MaydayClient)Client).NetworkManager = this;
return(Client);
}
public async Task SetupAsync()
{
ConfigureServices();
Logger logger = ServiceProvider.GetService <ILoggerProvider>()
.GetLogger("Server");
logger.LogInformation("Starting server");
ServerConfig config = ServiceProvider.GetService <IConfigProvider>().Config;
SteamServerInit init = new SteamServerInit
{
GamePort = config.Port,
Secure = true,
QueryPort = (ushort)(config.Port + 1),
SteamPort = (ushort)(config.Port + 2),
VersionString = "0.1",
DedicatedServer = true,
IpAddress = IPAddress.Parse(config.IpAddress),
ModDir = "pf",
GameDescription = "Pony Forest"
};
try
{
SteamServer.Init(1026040, init);
SteamServer.ServerName = config.Name;
SteamServer.AutomaticHeartbeats = true;
SteamServer.DedicatedServer = true;
SteamServer.Passworded = false;
SteamServer.MaxPlayers = config.MaxPlayers;
SteamServer.LogOnAnonymous();
NetAddress address = NetAddress.From(config.IpAddress, config.Port);
_serverCore = SteamNetworkingSockets.CreateNormalSocket <ServerCore>(address);
}
catch (Exception e)
{
logger.LogFailure($"Can't start server: {Environment.NewLine + e}");
}
try
{
IMessageRouter messageRouter = ServiceProvider.GetService <IMessageRouter>();
logger.LogInformation("Server started");
_serverCore.OnMessageReceived = messageRouter.Route;
IMessageListener messageListener = ServiceProvider.GetService <IMessageListener>();
await messageListener.StartListening(_serverCore);
}
catch (Exception e)
{
logger.LogFailure($"Error while running server: {Environment.NewLine + e}");
}
}
private void InternalDisconnect()
{
Connected = false;
OnDisconnected.Invoke();
Debug.Log("Disconnected.");
SteamNetworkingSockets.CloseConnection(HostConnection, 0, "Disconnected", false);
}
/// <summary>
/// Closes the socket, stops receiving messages from other peers
/// </summary>
public async void Close()
{
switch (_isServer)
{
case true:
SteamNetworkingSockets.CloseListenSocket(_steamSocketManager.Socket);
break;
case false:
// Thx to Refeas for this helps better disconnection.
byte[] data = new byte[3];
data[0] = (byte)PacketType.Command;
data[1] = (byte)Commands.Disconnect;
data[2] = (byte)DisconnectReason.RequestedByRemotePeer;
Send(_endPoint, data, data.Length);
SteamNetworkingSockets.FlushMessagesOnConnection(_steamSocketManager.HoHSteamNetConnection);
await Task.Delay(10);
SteamNetworkingSockets.CloseConnection(_steamSocketManager.HoHSteamNetConnection,
(int)ESteamNetConnectionEnd.k_ESteamNetConnectionEnd_App_Generic, null, false);
break;
}
_steamSocketManager.Dispose();
Debug.Log("Shutting down FizzySteam Sockets");
}
/// <summary>
/// Sets up Socket ready to send data to endpoint as a client
/// </summary>
/// <param name="endPoint"></param>
public void Connect(IEndPoint endPoint)
{
switch (_steamOptions.SteamMode)
{
case SteamModes.P2P:
var steamEndPoint = (SteamEndpoint)endPoint;
var steamIdentity = new SteamNetworkingIdentity();
steamIdentity.SetSteamID(steamEndPoint.Address);
_steamSocketManager.HoHSteamNetConnection = SteamNetworkingSockets.ConnectP2P(ref steamIdentity, 0, 0, Array.Empty <SteamNetworkingConfigValue_t>());
_steamSocketManager.SteamConnections.Add(steamEndPoint, _steamSocketManager.HoHSteamNetConnection);
break;
case SteamModes.UDP:
_endPoint = (SteamSocketFactory.SteamEndPointWrapper)endPoint;
var address = new SteamNetworkingIPAddr();
address.SetIPv6(((IPEndPoint)_endPoint.inner).Address.GetAddressBytes(), (ushort)((IPEndPoint)_endPoint.inner).Port);
_steamSocketManager.HoHSteamNetConnection =
SteamNetworkingSockets.ConnectByIPAddress(ref address, 0,
Array.Empty <SteamNetworkingConfigValue_t>());
_steamSocketManager.SteamConnections.Add(_endPoint, _steamSocketManager.HoHSteamNetConnection);
break;
default:
Debug.LogWarning("Unknown steam mode. Please check if mode has been supported.");
break;
}
}
/// <summary>
/// Starts listens for data on an endpoint
/// <para>Used by Server to allow clients to connect</para>
/// </summary>
/// <param name="endPoint">the endpoint to listen on</param>
public void Bind(IEndPoint endPoint)
{
switch (_steamOptions.SteamMode)
{
case SteamModes.P2P:
_steamSocketManager.Socket =
SteamNetworkingSockets.CreateListenSocketP2P(0, 0, Array.Empty <SteamNetworkingConfigValue_t>());
break;
case SteamModes.UDP:
_endPoint = (SteamSocketFactory.SteamEndPointWrapper)endPoint;
var address = new SteamNetworkingIPAddr();
address.SetIPv6(((IPEndPoint)_endPoint.inner).Address.GetAddressBytes(), (ushort)((IPEndPoint)_endPoint.inner).Port);
_steamSocketManager.Socket =
SteamNetworkingSockets.CreateListenSocketIP(ref address, 0,
Array.Empty <SteamNetworkingConfigValue_t>());
break;
default:
_steamSocketManager.LogDebug("Unknown steam mode. Please check if mode has been supported.", LogType.Warning);
throw new NotImplementedException("Unknown steam mode. This mode must not be implemented fully yet.");
}
}
public bool Update()
{
var receivedMessages = new IntPtr[_steamOptions.MaxMessagesPolling];
int receivedCount;
if ((receivedCount = SteamNetworkingSockets.ReceiveMessagesOnPollGroup(_pollGroup, receivedMessages,
_steamOptions.MaxMessagesPolling)) > 0)
{
for (int i = 0; i < receivedCount; i++)
{
SteamNetworkingMessage_t steamMessage = SteamNetworkingMessage_t.FromIntPtr(receivedMessages[i]);
var message = new Message
{
Data = new byte[steamMessage.m_cbSize],
Endpoint = FindKeyByValue(SteamConnections, steamMessage.m_conn)
};
Marshal.Copy(steamMessage.m_pData, message.Data, 0, steamMessage.m_cbSize);
BufferQueue.Enqueue(message);
if (_steamOptions.EnableDebug)
{
LogDebug(
$"Steam back-end queuing up messages to buffer. Current Message queue: {BufferQueue.Count}");
}
SteamNetworkingMessage_t.Release(receivedMessages[i]);
}
}
return(BufferQueue.Count > 0);
}
// Token: 0x0600097F RID: 2431 RVA: 0x00045AF0 File Offset: 0x00043CF0
public ZSteamSocket(CSteamID peerID)
{
ZSteamSocket.RegisterGlobalCallbacks();
this.m_peerID.SetSteamID(peerID);
this.m_con = SteamNetworkingSockets.ConnectP2P(ref this.m_peerID, 0, 0, null);
ZLog.Log("Connecting to " + this.m_peerID.GetSteamID().ToString());
ZSteamSocket.m_sockets.Add(this);
}
// Token: 0x0600098D RID: 2445 RVA: 0x00046164 File Offset: 0x00044364
public bool Flush()
{
this.SendQueuedPackages();
HSteamNetConnection con = this.m_con;
SteamNetworkingSockets.FlushMessagesOnConnection(this.m_con);
return(this.m_sendQueue.Count == 0);
}
private void InternalDisconnect(int connId, HSteamNetConnection socket)
{
OnDisconnected.Invoke(connId);
SteamNetworkingSockets.CloseConnection(socket, 0, "Graceful disconnect", false);
connToMirrorID.Remove(connId);
steamIDToMirrorID.Remove(connId);
Debug.Log($"Client with ConnectionID {connId} disconnected.");
}
private async void Connect(string host)
{
cancelToken = new CancellationTokenSource();
c_onConnectionChange = Callback <SteamNetConnectionStatusChangedCallback_t> .Create(OnConnectionStatusChanged);
try
{
hostSteamID = new CSteamID(UInt64.Parse(host));
connectedComplete = new TaskCompletionSource <Task>();
OnConnected += SetConnectedComplete;
SteamNetworkingIdentity smi = new SteamNetworkingIdentity();
smi.SetSteamID(hostSteamID);
SteamNetworkingConfigValue_t[] options = new SteamNetworkingConfigValue_t[] { };
HostConnection = SteamNetworkingSockets.ConnectP2P(ref smi, 0, options.Length, options);
Task connectedCompleteTask = connectedComplete.Task;
Task timeOutTask = Task.Delay(ConnectionTimeout, cancelToken.Token);
if (await Task.WhenAny(connectedCompleteTask, timeOutTask) != connectedCompleteTask)
{
if (cancelToken.IsCancellationRequested)
{
Debug.LogError($"The connection attempt was cancelled.");
}
else if (timeOutTask.IsCompleted)
{
Debug.LogError($"Connection to {host} timed out.");
}
OnConnected -= SetConnectedComplete;
OnConnectionFailed();
}
OnConnected -= SetConnectedComplete;
}
catch (FormatException)
{
Debug.LogError($"Connection string was not in the right format. Did you enter a SteamId?");
Error = true;
OnConnectionFailed();
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
Error = true;
OnConnectionFailed();
}
finally
{
if (Error)
{
Debug.LogError("Connection failed.");
OnConnectionFailed();
}
}
}
// Token: 0x0600097E RID: 2430 RVA: 0x00045A6C File Offset: 0x00043C6C
public ZSteamSocket(SteamNetworkingIPAddr host)
{
ZSteamSocket.RegisterGlobalCallbacks();
string str;
host.ToString(out str, true);
ZLog.Log("Starting to connect to " + str);
this.m_con = SteamNetworkingSockets.ConnectByIPAddress(ref host, 0, null);
ZSteamSocket.m_sockets.Add(this);
}
public void Shutdown()
{
SteamNetworkingSockets.CloseListenSocket(listenSocket);
if (c_onConnectionChange != null)
{
c_onConnectionChange.Dispose();
c_onConnectionChange = null;
}
}
// Token: 0x06000988 RID: 2440 RVA: 0x00046094 File Offset: 0x00044294
private void OnNewConnection(HSteamNetConnection con)
{
EResult eresult = SteamNetworkingSockets.AcceptConnection(con);
ZLog.Log("Accepting connection " + eresult);
if (eresult == EResult.k_EResultOK)
{
this.QueuePendingConnection(con);
}
}
public override void ClientConnect(string address)
{
if (useRelay)
{
Client = SteamNetworkingSockets.ConnectRelay <ClientManager>(targetSteamId);
}
else
{
Client = SteamNetworkingSockets.ConnectNormal <ClientManager>(NetAddress.From(address, port));
}
}
// Token: 0x06000980 RID: 2432 RVA: 0x00045B94 File Offset: 0x00043D94
public ZSteamSocket(HSteamNetConnection con)
{
ZSteamSocket.RegisterGlobalCallbacks();
this.m_con = con;
SteamNetConnectionInfo_t steamNetConnectionInfo_t;
SteamNetworkingSockets.GetConnectionInfo(this.m_con, out steamNetConnectionInfo_t);
this.m_peerID = steamNetConnectionInfo_t.m_identityRemote;
ZLog.Log("Connecting to " + this.m_peerID.ToString());
ZSteamSocket.m_sockets.Add(this);
}
// Token: 0x06000983 RID: 2435 RVA: 0x00045D30 File Offset: 0x00043F30
private static void OnStatusChanged(SteamNetConnectionStatusChangedCallback_t data)
{
ZLog.Log("Got status changed msg " + data.m_info.m_eState);
if (data.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_Connected && data.m_eOldState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_Connecting)
{
ZLog.Log("Connected");
ZSteamSocket zsteamSocket = ZSteamSocket.FindSocket(data.m_hConn);
if (zsteamSocket != null)
{
SteamNetConnectionInfo_t steamNetConnectionInfo_t;
if (SteamNetworkingSockets.GetConnectionInfo(data.m_hConn, out steamNetConnectionInfo_t))
{
zsteamSocket.m_peerID = steamNetConnectionInfo_t.m_identityRemote;
}
ZLog.Log("Got connection SteamID " + zsteamSocket.m_peerID.GetSteamID().ToString());
}
}
if (data.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_Connecting && data.m_eOldState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_None)
{
ZLog.Log("New connection");
ZSteamSocket listner = ZSteamSocket.GetListner();
if (listner != null)
{
listner.OnNewConnection(data.m_hConn);
}
}
if (data.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_ProblemDetectedLocally)
{
ZLog.Log(string.Concat(new object[]
{
"Got problem ",
data.m_info.m_eEndReason,
":",
data.m_info.m_szEndDebug
}));
ZSteamSocket zsteamSocket2 = ZSteamSocket.FindSocket(data.m_hConn);
if (zsteamSocket2 != null)
{
ZLog.Log(" Closing socket " + zsteamSocket2.GetHostName());
zsteamSocket2.Close();
}
}
if (data.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_ClosedByPeer)
{
ZLog.Log("Socket closed by peer " + data);
ZSteamSocket zsteamSocket3 = ZSteamSocket.FindSocket(data.m_hConn);
if (zsteamSocket3 != null)
{
ZLog.Log(" Closing socket " + zsteamSocket3.GetHostName());
zsteamSocket3.Close();
}
}
}
public void Disconnect()
{
cancelToken?.Cancel();
Dispose();
if (HostConnection.m_HSteamNetConnection != 0)
{
Debug.Log("Sending Disconnect message");
SteamNetworkingSockets.CloseConnection(HostConnection, 0, "Graceful disconnect", false);
HostConnection.m_HSteamNetConnection = 0;
}
}
// Token: 0x06000987 RID: 2439 RVA: 0x0004605F File Offset: 0x0004425F
public bool StartHost()
{
if (ZSteamSocket.m_hostSocket != null)
{
ZLog.Log("Listen socket already started");
return(false);
}
this.m_listenSocket = SteamNetworkingSockets.CreateListenSocketP2P(0, 0, null);
ZSteamSocket.m_hostSocket = this;
this.m_pendingConnections.Clear();
return(true);
}
public override void ServerStart()
{
if (useRelay)
{
Server = SteamNetworkingSockets.CreateRelaySocket <ServerManager>();
}
else
{
Server = SteamNetworkingSockets.CreateNormalSocket <ServerManager>(NetAddress.AnyIp(port));
}
serverActive = true;
}
private async void Connect(string host)
{
cancelToken = new CancellationTokenSource();
SteamNetworkingSockets.OnConnectionStatusChanged += OnConnectionStatusChanged;
try
{
hostSteamID = UInt64.Parse(host);
connectedComplete = new TaskCompletionSource <Task>();
OnConnected += SetConnectedComplete;
HostConnectionManager = SteamNetworkingSockets.ConnectRelay <FizzyConnectionManager>(hostSteamID);
HostConnectionManager.ForwardMessage = OnMessageReceived;
Task connectedCompleteTask = connectedComplete.Task;
Task timeOutTask = Task.Delay(ConnectionTimeout, cancelToken.Token);
if (await Task.WhenAny(connectedCompleteTask, timeOutTask) != connectedCompleteTask)
{
if (cancelToken.IsCancellationRequested)
{
Debug.LogError($"The connection attempt was cancelled.");
}
else if (timeOutTask.IsCompleted)
{
Debug.LogError($"Connection to {host} timed out.");
}
OnConnected -= SetConnectedComplete;
OnConnectionFailed();
}
OnConnected -= SetConnectedComplete;
}
catch (FormatException)
{
Debug.LogError($"Connection string was not in the right format. Did you enter a SteamId?");
Error = true;
OnConnectionFailed();
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
Error = true;
OnConnectionFailed();
}
finally
{
if (Error)
{
Debug.LogError("Connection failed.");
OnConnectionFailed();
}
}
}
// Token: 0x060009E2 RID: 2530 RVA: 0x00047BC4 File Offset: 0x00045DC4
private void Awake()
{
if (SteamManager.s_instance != null)
{
UnityEngine.Object.Destroy(base.gameObject);
return;
}
SteamManager.s_instance = this;
SteamManager.APP_ID = this.LoadAPPID();
ZLog.Log("Using steam APPID:" + SteamManager.APP_ID.ToString());
if (!SteamManager.ACCEPTED_APPIDs.Contains(SteamManager.APP_ID))
{
ZLog.Log("Invalid APPID");
Application.Quit();
return;
}
if (SteamManager.s_EverInialized)
{
throw new Exception("Tried to Initialize the SteamAPI twice in one session!");
}
UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
if (!Packsize.Test())
{
Debug.LogError("[Steamworks.NET] Packsize Test returned false, the wrong version of Steamworks.NET is being run in this platform.", this);
}
if (!DllCheck.Test())
{
Debug.LogError("[Steamworks.NET] DllCheck Test returned false, One or more of the Steamworks binaries seems to be the wrong version.", this);
}
try
{
if (SteamAPI.RestartAppIfNecessary((AppId_t)SteamManager.APP_ID))
{
Application.Quit();
return;
}
}
catch (DllNotFoundException arg)
{
Debug.LogError("[Steamworks.NET] Could not load [lib]steam_api.dll/so/dylib. It's likely not in the correct location. Refer to the README for more details.\n" + arg, this);
Application.Quit();
return;
}
this.m_bInitialized = SteamAPI.Init();
if (!this.m_bInitialized)
{
Debug.LogError("[Steamworks.NET] SteamAPI_Init() failed. Refer to Valve's documentation or the comment above this line for more information.", this);
return;
}
ZLog.Log("Authentication:" + SteamNetworkingSockets.InitAuthentication().ToString());
SteamManager.s_EverInialized = true;
}
public SocketManager CreateSession(string port)
{
var netAddress = NetAddress.AnyIp(ushort.Parse(port));
Server = SteamNetworkingSockets.CreateNormalSocket <MaydayServer>(netAddress);
((MaydayServer)Server).NetworkManager = this;
SteamMatchmaking.OnLobbyCreated += (result, lobby) => OnLobbyCreated(result, lobby, port);
SteamMatchmaking.CreateLobbyAsync();
return(Server);
}
private IEnumerator StartServerRoutine()
{
yield return(new WaitUntil(() => SteamServer.IsValid));
if (useRelay)
{
Server = SteamNetworkingSockets.CreateRelaySocket <ServerInterface>();
}
else
{
Server = SteamNetworkingSockets.CreateNormalSocket <ServerInterface>(NetAddress.AnyIp(port));
}
serverActive = true;
}
public void Disconnect(int connectionId)
{
if (connToMirrorID.TryGetValue(connectionId, out HSteamNetConnection conn))
{
Debug.Log($"Connection id {connectionId} disconnected.");
SteamNetworkingSockets.CloseConnection(conn, 0, "Disconnected by server", false);
steamIDToMirrorID.Remove(connectionId);
connToMirrorID.Remove(connectionId);
OnDisconnected(connectionId);
}
else
{
Debug.LogWarning("Trying to disconnect unknown connection id: " + connectionId);
}
}
private void OnConnectionStatusChanged(SteamNetConnectionStatusChangedCallback_t param)
{
ulong clientSteamID = param.m_info.m_identityRemote.GetSteamID64();
if (param.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_Connecting)
{
if (connToMirrorID.Count >= maxConnections)
{
Debug.Log($"Incoming connection {clientSteamID} would exceed max connection count. Rejecting.");
SteamNetworkingSockets.CloseConnection(param.m_hConn, 0, "Max Connection Count", false);
return;
}
EResult res;
if ((res = SteamNetworkingSockets.AcceptConnection(param.m_hConn)) == EResult.k_EResultOK)
{
Debug.Log($"Accepting connection {clientSteamID}");
}
else
{
Debug.Log($"Connection {clientSteamID} could not be accepted: {res.ToString()}");
}
}
else if (param.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_Connected)
{
int connectionId = nextConnectionID++;
connToMirrorID.Add(param.m_hConn, connectionId);
steamIDToMirrorID.Add(param.m_info.m_identityRemote.GetSteamID(), connectionId);
OnConnected.Invoke(connectionId);
Debug.Log($"Client with SteamID {clientSteamID} connected. Assigning connection id {connectionId}");
}
else if (param.m_info.m_eState == ESteamNetworkingConnectionState.k_ESteamNetworkingConnectionState_ClosedByPeer)
{
if (connToMirrorID.TryGetValue(param.m_hConn, out int connId))
{
OnDisconnected.Invoke(connId);
SteamNetworkingSockets.CloseConnection(param.m_hConn, 0, "Graceful disconnect", false);
connToMirrorID.Remove(connId);
steamIDToMirrorID.Remove(connId);
Debug.Log($"Client with SteamID {clientSteamID} disconnected.");
}
}
else
{
Debug.Log($"Connection {clientSteamID} state changed: {param.m_info.m_eState.ToString()}");
}
}
