Bump FN 4.16

Tyro-Games · Tyro-Games · commit 091a51bafcfa · 2024-04-03T00:41:59.000+02:00
diff --git a/FishNet/Plugins/FishyFacepunch/Core/ClientSocket.cs b/FishNet/Plugins/FishyFacepunch/Core/ClientSocket.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using FishNet.Managing;
 using UnityEngine;
 
 namespace FishyFacepunch.Client
@@ -87,45 +88,39 @@ internal async void StartConnection(string address, ushort port)
                     {
                         if (cancelToken.IsCancellationRequested)
                         {
-                            if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                                Debug.LogError($"The connection attempt was cancelled.");
+                            Transport.NetworkManager.LogError($"The connection attempt was cancelled.");
                         }
                         else if (timeOutTask.IsCompleted)
                         {
-                            if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                                Debug.LogError($"Connection to {address} timed out.");
+                            Transport.NetworkManager.LogError($"Connection to {address} timed out.");
                             StopConnection();
                         }
                         SetLocalConnectionState(LocalConnectionState.Stopped, false);
                     }
                 }
                 else
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                        Debug.LogError("SteamWorks not initialized");
+                    Transport.NetworkManager.LogError("SteamWorks not initialized");
                     SetLocalConnectionState(LocalConnectionState.Stopped, false);
                 }
             }
             catch (FormatException)
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                    Debug.LogError($"Connection string was not in the right format. Did you enter a SteamId?");
+                Transport.NetworkManager.LogError($"Connection string was not in the right format. Did you enter a SteamId?");
                 SetLocalConnectionState(LocalConnectionState.Stopped, false);
                 _Error = true;
             }
             catch (Exception ex)
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                    Debug.LogError(ex.Message);
+                Transport.NetworkManager.LogError(ex.Message);
                 SetLocalConnectionState(LocalConnectionState.Stopped, false);
                 _Error = true;
             }
             finally
             {
                 if (_Error)
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                        Debug.LogError("Connection failed.");
+                    Transport.NetworkManager.LogError("Connection failed.");
                     SetLocalConnectionState(LocalConnectionState.Stopped, false);
                 }
             }
@@ -143,14 +138,12 @@ private void OnConnectionStatusChanged(Connection conn, ConnectionInfo info)
             }
             else if (info.State == ConnectionState.ClosedByPeer || info.State == ConnectionState.ProblemDetectedLocally)
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                    Debug.Log($"Connection was closed by peer, {info.EndReason}");
+                Transport.NetworkManager.Log($"Connection was closed by peer, {info.EndReason}");
                 StopConnection();
             }
             else
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                    Debug.Log($"Connection state changed: {info.State.ToString()} - {info.EndReason}");
+                Transport.NetworkManager.Log($"Connection state changed: {info.State.ToString()} - {info.EndReason}");
             }
         }
 
@@ -171,8 +164,7 @@ internal bool StopConnection()
 
             if (HostConnectionManager != null)
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                    Debug.Log("Sending Disconnect message");
+                Transport.NetworkManager.Log("Sending Disconnect message");
                 HostConnection.Close(false, 0, "Graceful disconnect");
                 HostConnectionManager = null;
             }
@@ -212,14 +204,12 @@ internal void SendToServer(byte channelId, ArraySegment<byte> segment)
             Result res = base.Send(HostConnection, segment, channelId);
             if (res == Result.NoConnection || res == Result.InvalidParam)
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                    Debug.Log($"Connection to server was lost.");
+                Transport.NetworkManager.Log($"Connection to server was lost.");
                 StopConnection();
             }
             else if (res != Result.OK)
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                    Debug.LogError($"Could not send: {res.ToString()}");
+                Transport.NetworkManager.LogError($"Could not send: {res.ToString()}");
             }
         }
 
diff --git a/FishNet/Plugins/FishyFacepunch/Core/CommonSocket.cs b/FishNet/Plugins/FishyFacepunch/Core/CommonSocket.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Net;
 using System.Runtime.InteropServices;
+using FishNet.Managing;
 using UnityEngine;
 
 namespace FishyFacepunch
@@ -150,8 +151,7 @@ protected Result Send(Connection conn, ArraySegment<byte> segment, byte channelI
             Result result = conn.SendMessage(pData, segment.Count, sendFlag);
             if (result != Result.OK)
             {
-                if (Transport.NetworkManager.CanLog(LoggingType.Warning))
-                    Debug.LogWarning($"Send issue: {result}");
+                Transport.NetworkManager.LogWarning($"Send issue: {result}");
             }
 
             pinnedArray.Free();
diff --git a/FishNet/Plugins/FishyFacepunch/Core/ServerSocket.cs b/FishNet/Plugins/FishyFacepunch/Core/ServerSocket.cs
@@ -6,6 +6,7 @@
 using Steamworks.Data;
 using System;
 using System.Collections.Generic;
+using FishNet.Managing;
 using UnityEngine;
 
 namespace FishyFacepunch.Server
@@ -167,8 +168,7 @@ internal bool StopConnection(int connectionId)
                 }
                 else
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                        Debug.LogError($"Steam connection not found for connectionId {connectionId}.");
+                    Transport.NetworkManager.LogError($"Steam connection not found for connectionId {connectionId}.");
                     return false;
                 }
             }            
@@ -183,8 +183,7 @@ private bool StopConnection(int connectionId, Connection socket)
             socket.Close(false, 0, "Graceful disconnect");
             _steamConnections.Remove(connectionId);
             _steamIds.Remove(connectionId);
-            if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                Debug.Log($"Client with ConnectionID {connectionId} disconnected.");
+            Transport.NetworkManager.Log($"Client with ConnectionID {connectionId} disconnected.");
             base.Transport.HandleRemoteConnectionState(new RemoteConnectionStateArgs(RemoteConnectionState.Stopped, connectionId, Transport.Index));
             _cachedConnectionIds.Enqueue(connectionId);
 
@@ -201,8 +200,7 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)
             {
                 if (_steamConnections.Count >= _maximumClients)
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                        Debug.Log($"Incoming connection {clientSteamID} was rejected because would exceed the maximum connection count.");
+                    Transport.NetworkManager.Log($"Incoming connection {clientSteamID} was rejected because would exceed the maximum connection count.");
 
                     conn.Close(false, 0, "Max Connection Count");
                     return;
@@ -212,13 +210,11 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)
 
                 if ((res = conn.Accept()) == Result.OK)
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                        Debug.Log($"Accepting connection {clientSteamID}");
+                    Transport.NetworkManager.Log($"Accepting connection {clientSteamID}");
                 }
                 else
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                        Debug.Log($"Connection {clientSteamID} could not be accepted: {res.ToString()}");
+                    Transport.NetworkManager.Log($"Connection {clientSteamID} could not be accepted: {res.ToString()}");
                 }
             }
             else if (info.State == ConnectionState.Connected)
@@ -227,8 +223,7 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)
                 _steamConnections.Add(conn, connectionId);
                 _steamIds.Add(clientSteamID, connectionId);
 
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                    Debug.Log($"Client with SteamID {clientSteamID} connected. Assigning connection id {connectionId}");
+                Transport.NetworkManager.Log($"Client with SteamID {clientSteamID} connected. Assigning connection id {connectionId}");
                 base.Transport.HandleRemoteConnectionState(new RemoteConnectionStateArgs(RemoteConnectionState.Started, connectionId, Transport.Index));
             }
             else if (info.State == ConnectionState.ClosedByPeer || info.State == ConnectionState.ProblemDetectedLocally)
@@ -240,8 +235,7 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)
             }
             else
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                    Debug.Log($"Connection {clientSteamID} state changed: {info.State.ToString()}");
+                Transport.NetworkManager.Log($"Connection {clientSteamID} state changed: {info.State.ToString()}");
             }
         }
 
@@ -316,20 +310,17 @@ internal void SendToClient(byte channelId, ArraySegment<byte> segment, int conne
 
                 if (res == Result.NoConnection || res == Result.InvalidParam)
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Common))
-                        Debug.Log($"Connection to {connectionId} was lost.");
+                    Transport.NetworkManager.Log($"Connection to {connectionId} was lost.");
                     StopConnection(connectionId, steamConn);
                 }
                 else if (res != Result.OK)
                 {
-                    if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                        Debug.LogError($"Could not send: {res.ToString()}");
+                    Transport.NetworkManager.LogError($"Could not send: {res.ToString()}");
                 }
             }
             else
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                    Debug.LogError($"ConnectionId {connectionId} does not exist, data will not be sent.");
+                Transport.NetworkManager.LogError($"ConnectionId {connectionId} does not exist, data will not be sent.");
             }
         }
 
@@ -346,8 +337,7 @@ internal string GetConnectionAddress(int connectionId)
             }
             else
             {
-                if (base.Transport.NetworkManager.CanLog(LoggingType.Error))
-                    Debug.LogError($"ConnectionId {connectionId} is invalid; address cannot be returned.");
+                Transport.NetworkManager.LogError($"ConnectionId {connectionId} is invalid; address cannot be returned.");
 
                 return string.Empty;
             }

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`using System;`
`7`	`7`	`using System.Threading;`
`8`	`8`	`using System.Threading.Tasks;`
	`9`	`+using FishNet.Managing;`
`9`	`10`	`using UnityEngine;`
`10`	`11`
`11`	`12`	`namespace FishyFacepunch.Client`
`@@ -87,45 +88,39 @@ internal async void StartConnection(string address, ushort port)`
`87`	`88`	`{`
`88`	`89`	`if (cancelToken.IsCancellationRequested)`
`89`	`90`	`{`
`90`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`91`		`- Debug.LogError($"The connection attempt was cancelled.");`
	`91`	`+ Transport.NetworkManager.LogError($"The connection attempt was cancelled.");`
`92`	`92`	`}`
`93`	`93`	`else if (timeOutTask.IsCompleted)`
`94`	`94`	`{`
`95`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`96`		`- Debug.LogError($"Connection to {address} timed out.");`
	`95`	`+ Transport.NetworkManager.LogError($"Connection to {address} timed out.");`
`97`	`96`	`StopConnection();`
`98`	`97`	`}`
`99`	`98`	`SetLocalConnectionState(LocalConnectionState.Stopped, false);`
`100`	`99`	`}`
`101`	`100`	`}`
`102`	`101`	`else`
`103`	`102`	`{`
`104`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`105`		`- Debug.LogError("SteamWorks not initialized");`
	`103`	`+ Transport.NetworkManager.LogError("SteamWorks not initialized");`
`106`	`104`	`SetLocalConnectionState(LocalConnectionState.Stopped, false);`
`107`	`105`	`}`
`108`	`106`	`}`
`109`	`107`	`catch (FormatException)`
`110`	`108`	`{`
`111`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`112`		`- Debug.LogError($"Connection string was not in the right format. Did you enter a SteamId?");`
	`109`	`+ Transport.NetworkManager.LogError($"Connection string was not in the right format. Did you enter a SteamId?");`
`113`	`110`	`SetLocalConnectionState(LocalConnectionState.Stopped, false);`
`114`	`111`	`_Error = true;`
`115`	`112`	`}`
`116`	`113`	`catch (Exception ex)`
`117`	`114`	`{`
`118`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`119`		`- Debug.LogError(ex.Message);`
	`115`	`+ Transport.NetworkManager.LogError(ex.Message);`
`120`	`116`	`SetLocalConnectionState(LocalConnectionState.Stopped, false);`
`121`	`117`	`_Error = true;`
`122`	`118`	`}`
`123`	`119`	`finally`
`124`	`120`	`{`
`125`	`121`	`if (_Error)`
`126`	`122`	`{`
`127`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`128`		`- Debug.LogError("Connection failed.");`
	`123`	`+ Transport.NetworkManager.LogError("Connection failed.");`
`129`	`124`	`SetLocalConnectionState(LocalConnectionState.Stopped, false);`
`130`	`125`	`}`
`131`	`126`	`}`
`@@ -143,14 +138,12 @@ private void OnConnectionStatusChanged(Connection conn, ConnectionInfo info)`
`143`	`138`	`}`
`144`	`139`	`else if (info.State == ConnectionState.ClosedByPeer \|\| info.State == ConnectionState.ProblemDetectedLocally)`
`145`	`140`	`{`
`146`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`147`		`- Debug.Log($"Connection was closed by peer, {info.EndReason}");`
	`141`	`+ Transport.NetworkManager.Log($"Connection was closed by peer, {info.EndReason}");`
`148`	`142`	`StopConnection();`
`149`	`143`	`}`
`150`	`144`	`else`
`151`	`145`	`{`
`152`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`153`		`- Debug.Log($"Connection state changed: {info.State.ToString()} - {info.EndReason}");`
	`146`	`+ Transport.NetworkManager.Log($"Connection state changed: {info.State.ToString()} - {info.EndReason}");`
`154`	`147`	`}`
`155`	`148`	`}`
`156`	`149`
`@@ -171,8 +164,7 @@ internal bool StopConnection()`
`171`	`164`
`172`	`165`	`if (HostConnectionManager != null)`
`173`	`166`	`{`
`174`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`175`		`- Debug.Log("Sending Disconnect message");`
	`167`	`+ Transport.NetworkManager.Log("Sending Disconnect message");`
`176`	`168`	`HostConnection.Close(false, 0, "Graceful disconnect");`
`177`	`169`	`HostConnectionManager = null;`
`178`	`170`	`}`
`@@ -212,14 +204,12 @@ internal void SendToServer(byte channelId, ArraySegment<byte> segment)`
`212`	`204`	`Result res = base.Send(HostConnection, segment, channelId);`
`213`	`205`	`if (res == Result.NoConnection \|\| res == Result.InvalidParam)`
`214`	`206`	`{`
`215`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`216`		`- Debug.Log($"Connection to server was lost.");`
	`207`	`+ Transport.NetworkManager.Log($"Connection to server was lost.");`
`217`	`208`	`StopConnection();`
`218`	`209`	`}`
`219`	`210`	`else if (res != Result.OK)`
`220`	`211`	`{`
`221`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`222`		`- Debug.LogError($"Could not send: {res.ToString()}");`
	`212`	`+ Transport.NetworkManager.LogError($"Could not send: {res.ToString()}");`
`223`	`213`	`}`
`224`	`214`	`}`
`225`	`215`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`using Steamworks.Data;`
`7`	`7`	`using System;`
`8`	`8`	`using System.Collections.Generic;`
	`9`	`+using FishNet.Managing;`
`9`	`10`	`using UnityEngine;`
`10`	`11`
`11`	`12`	`namespace FishyFacepunch.Server`
`@@ -167,8 +168,7 @@ internal bool StopConnection(int connectionId)`
`167`	`168`	`}`
`168`	`169`	`else`
`169`	`170`	`{`
`170`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`171`		`- Debug.LogError($"Steam connection not found for connectionId {connectionId}.");`
	`171`	`+ Transport.NetworkManager.LogError($"Steam connection not found for connectionId {connectionId}.");`
`172`	`172`	`return false;`
`173`	`173`	`}`
`174`	`174`	`}`
`@@ -183,8 +183,7 @@ private bool StopConnection(int connectionId, Connection socket)`
`183`	`183`	`socket.Close(false, 0, "Graceful disconnect");`
`184`	`184`	`_steamConnections.Remove(connectionId);`
`185`	`185`	`_steamIds.Remove(connectionId);`
`186`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`187`		`- Debug.Log($"Client with ConnectionID {connectionId} disconnected.");`
	`186`	`+ Transport.NetworkManager.Log($"Client with ConnectionID {connectionId} disconnected.");`
`188`	`187`	`base.Transport.HandleRemoteConnectionState(new RemoteConnectionStateArgs(RemoteConnectionState.Stopped, connectionId, Transport.Index));`
`189`	`188`	`_cachedConnectionIds.Enqueue(connectionId);`
`190`	`189`
`@@ -201,8 +200,7 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)`
`201`	`200`	`{`
`202`	`201`	`if (_steamConnections.Count >= _maximumClients)`
`203`	`202`	`{`
`204`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`205`		`- Debug.Log($"Incoming connection {clientSteamID} was rejected because would exceed the maximum connection count.");`
	`203`	`+ Transport.NetworkManager.Log($"Incoming connection {clientSteamID} was rejected because would exceed the maximum connection count.");`
`206`	`204`
`207`	`205`	`conn.Close(false, 0, "Max Connection Count");`
`208`	`206`	`return;`
`@@ -212,13 +210,11 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)`
`212`	`210`
`213`	`211`	`if ((res = conn.Accept()) == Result.OK)`
`214`	`212`	`{`
`215`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`216`		`- Debug.Log($"Accepting connection {clientSteamID}");`
	`213`	`+ Transport.NetworkManager.Log($"Accepting connection {clientSteamID}");`
`217`	`214`	`}`
`218`	`215`	`else`
`219`	`216`	`{`
`220`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`221`		`- Debug.Log($"Connection {clientSteamID} could not be accepted: {res.ToString()}");`
	`217`	`+ Transport.NetworkManager.Log($"Connection {clientSteamID} could not be accepted: {res.ToString()}");`
`222`	`218`	`}`
`223`	`219`	`}`
`224`	`220`	`else if (info.State == ConnectionState.Connected)`
`@@ -227,8 +223,7 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)`
`227`	`223`	`_steamConnections.Add(conn, connectionId);`
`228`	`224`	`_steamIds.Add(clientSteamID, connectionId);`
`229`	`225`
`230`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`231`		`- Debug.Log($"Client with SteamID {clientSteamID} connected. Assigning connection id {connectionId}");`
	`226`	`+ Transport.NetworkManager.Log($"Client with SteamID {clientSteamID} connected. Assigning connection id {connectionId}");`
`232`	`227`	`base.Transport.HandleRemoteConnectionState(new RemoteConnectionStateArgs(RemoteConnectionState.Started, connectionId, Transport.Index));`
`233`	`228`	`}`
`234`	`229`	`else if (info.State == ConnectionState.ClosedByPeer \|\| info.State == ConnectionState.ProblemDetectedLocally)`
`@@ -240,8 +235,7 @@ private void OnRemoteConnectionState(Connection conn, ConnectionInfo info)`
`240`	`235`	`}`
`241`	`236`	`else`
`242`	`237`	`{`
`243`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`244`		`- Debug.Log($"Connection {clientSteamID} state changed: {info.State.ToString()}");`
	`238`	`+ Transport.NetworkManager.Log($"Connection {clientSteamID} state changed: {info.State.ToString()}");`
`245`	`239`	`}`
`246`	`240`	`}`
`247`	`241`
`@@ -316,20 +310,17 @@ internal void SendToClient(byte channelId, ArraySegment<byte> segment, int conne`
`316`	`310`
`317`	`311`	`if (res == Result.NoConnection \|\| res == Result.InvalidParam)`
`318`	`312`	`{`
`319`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Common))`
`320`		`- Debug.Log($"Connection to {connectionId} was lost.");`
	`313`	`+ Transport.NetworkManager.Log($"Connection to {connectionId} was lost.");`
`321`	`314`	`StopConnection(connectionId, steamConn);`
`322`	`315`	`}`
`323`	`316`	`else if (res != Result.OK)`
`324`	`317`	`{`
`325`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`326`		`- Debug.LogError($"Could not send: {res.ToString()}");`
	`318`	`+ Transport.NetworkManager.LogError($"Could not send: {res.ToString()}");`
`327`	`319`	`}`
`328`	`320`	`}`
`329`	`321`	`else`
`330`	`322`	`{`
`331`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`332`		`- Debug.LogError($"ConnectionId {connectionId} does not exist, data will not be sent.");`
	`323`	`+ Transport.NetworkManager.LogError($"ConnectionId {connectionId} does not exist, data will not be sent.");`
`333`	`324`	`}`
`334`	`325`	`}`
`335`	`326`
`@@ -346,8 +337,7 @@ internal string GetConnectionAddress(int connectionId)`
`346`	`337`	`}`
`347`	`338`	`else`
`348`	`339`	`{`
`349`		`- if (base.Transport.NetworkManager.CanLog(LoggingType.Error))`
`350`		`- Debug.LogError($"ConnectionId {connectionId} is invalid; address cannot be returned.");`
	`340`	`+ Transport.NetworkManager.LogError($"ConnectionId {connectionId} is invalid; address cannot be returned.");`
`351`	`341`
`352`	`342`	`return string.Empty;`
`353`	`343`	`}`