mirror of
https://github.com/misternebula/quantum-space-buddies.git
synced 2025-01-09 12:54:51 +00:00
759 lines
20 KiB
C#
759 lines
20 KiB
C#
using QuantumUNET.Logging;
|
|
using QuantumUNET.Messages;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Networking;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
namespace QuantumUNET.Components
|
|
{
|
|
public class QNetworkManager : MonoBehaviour
|
|
{
|
|
public static QNetworkManager singleton;
|
|
public static string networkSceneName = "";
|
|
|
|
public int networkPort { get; set; } = 7777;
|
|
public int simulatedLatency { get; set; } = 1;
|
|
public bool serverBindToIP { get; set; }
|
|
public bool dontDestroyOnLoad { get; set; } = true;
|
|
public bool runInBackground { get; set; } = true;
|
|
public bool scriptCRCCheck { get; set; } = true;
|
|
public bool autoCreatePlayer { get; set; } = true;
|
|
public bool isNetworkActive;
|
|
public bool useWebSockets { get; set; }
|
|
public bool useSimulator { get; set; }
|
|
public bool clientLoadedScene { get; set; }
|
|
public string serverBindAddress { get; set; } = "";
|
|
public string networkAddress { get; set; } = "localhost";
|
|
public string offlineScene { get; set; } = "";
|
|
public string onlineScene { get; set; } = "";
|
|
public float packetLossPercentage { get; set; }
|
|
public float maxDelay { get; set; } = 0.01f;
|
|
public GameObject playerPrefab { get; set; }
|
|
public List<GameObject> spawnPrefabs { get; } = new List<GameObject>();
|
|
public QNetworkClient client;
|
|
public int maxConnections { get; set; } = 4;
|
|
public List<QosType> channels { get; } = new List<QosType>();
|
|
|
|
private ConnectionConfig m_ConnectionConfig;
|
|
private GlobalConfig m_GlobalConfig;
|
|
private readonly int m_MaxBufferedPackets = 16;
|
|
private readonly bool m_AllowFragmentation = true;
|
|
private static readonly QAddPlayerMessage s_AddPlayerMessage = new QAddPlayerMessage();
|
|
private static readonly QRemovePlayerMessage s_RemovePlayerMessage = new QRemovePlayerMessage();
|
|
private static readonly QErrorMessage s_ErrorMessage = new QErrorMessage();
|
|
private static AsyncOperation s_LoadingSceneAsync;
|
|
private static QNetworkConnection s_ClientReadyConnection;
|
|
private static string s_Address;
|
|
|
|
public bool customConfig { get; set; }
|
|
|
|
public ConnectionConfig connectionConfig
|
|
{
|
|
get
|
|
{
|
|
if (m_ConnectionConfig == null)
|
|
{
|
|
m_ConnectionConfig = new ConnectionConfig();
|
|
}
|
|
return m_ConnectionConfig;
|
|
}
|
|
}
|
|
|
|
public GlobalConfig globalConfig
|
|
{
|
|
get
|
|
{
|
|
if (m_GlobalConfig == null)
|
|
{
|
|
m_GlobalConfig = new GlobalConfig();
|
|
}
|
|
return m_GlobalConfig;
|
|
}
|
|
}
|
|
|
|
public int numPlayers
|
|
{
|
|
get
|
|
{
|
|
var num = 0;
|
|
foreach (var networkConnection in QNetworkServer.connections)
|
|
{
|
|
if (networkConnection != null)
|
|
{
|
|
foreach (var controller in networkConnection.PlayerControllers)
|
|
{
|
|
if (controller.IsValid)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
public void Awake() => InitializeSingleton();
|
|
|
|
private void InitializeSingleton()
|
|
{
|
|
if (!(singleton != null) || !(singleton == this))
|
|
{
|
|
if (dontDestroyOnLoad)
|
|
{
|
|
if (singleton != null)
|
|
{
|
|
QLog.Warning("Multiple NetworkManagers detected in the scene. Only one NetworkManager can exist at a time. The duplicate NetworkManager will not be used.");
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
QLog.Log("NetworkManager created singleton (DontDestroyOnLoad)");
|
|
singleton = this;
|
|
if (Application.isPlaying)
|
|
{
|
|
DontDestroyOnLoad(gameObject);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
QLog.Log("NetworkManager created singleton (ForScene)");
|
|
singleton = this;
|
|
}
|
|
if (networkAddress != "")
|
|
{
|
|
s_Address = networkAddress;
|
|
}
|
|
else if (s_Address != "")
|
|
{
|
|
networkAddress = s_Address;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RegisterServerMessages()
|
|
{
|
|
QNetworkServer.RegisterHandler(QMsgType.Connect, OnServerConnectInternal);
|
|
QNetworkServer.RegisterHandler(QMsgType.Disconnect, OnServerDisconnectInternal);
|
|
QNetworkServer.RegisterHandler(QMsgType.Ready, OnServerReadyMessageInternal);
|
|
QNetworkServer.RegisterHandler(QMsgType.AddPlayer, OnServerAddPlayerMessageInternal);
|
|
QNetworkServer.RegisterHandler(QMsgType.RemovePlayer, OnServerRemovePlayerMessageInternal);
|
|
QNetworkServer.RegisterHandler(QMsgType.Error, OnServerErrorInternal);
|
|
}
|
|
|
|
public bool StartServer() => StartServer(null, -1);
|
|
|
|
private bool StartServer(ConnectionConfig config, int maxConnections)
|
|
{
|
|
InitializeSingleton();
|
|
OnStartServer();
|
|
if (runInBackground)
|
|
{
|
|
Application.runInBackground = true;
|
|
}
|
|
QNetworkCRC.scriptCRCCheck = scriptCRCCheck;
|
|
QNetworkServer.useWebSockets = useWebSockets;
|
|
if (m_GlobalConfig != null)
|
|
{
|
|
NetworkTransport.Init(m_GlobalConfig);
|
|
}
|
|
if (customConfig && m_ConnectionConfig != null && config == null)
|
|
{
|
|
m_ConnectionConfig.Channels.Clear();
|
|
foreach (var channel in channels)
|
|
{
|
|
m_ConnectionConfig.AddChannel(channel);
|
|
}
|
|
QNetworkServer.Configure(m_ConnectionConfig, this.maxConnections);
|
|
}
|
|
if (config != null)
|
|
{
|
|
QNetworkServer.Configure(config, maxConnections);
|
|
}
|
|
if (serverBindToIP && !string.IsNullOrEmpty(serverBindAddress))
|
|
{
|
|
if (!QNetworkServer.Listen(serverBindAddress, networkPort))
|
|
{
|
|
QLog.FatalError($"StartServer listen on {serverBindAddress} failed.");
|
|
return false;
|
|
}
|
|
}
|
|
else if (!QNetworkServer.Listen(networkPort))
|
|
{
|
|
QLog.FatalError("StartServer listen failed.");
|
|
return false;
|
|
}
|
|
RegisterServerMessages();
|
|
QLog.Log($"NetworkManager StartServer port:{networkPort}");
|
|
isNetworkActive = true;
|
|
var name = SceneManager.GetSceneAt(0).name;
|
|
if (!string.IsNullOrEmpty(onlineScene) && onlineScene != name && onlineScene != offlineScene)
|
|
{
|
|
ServerChangeScene(onlineScene);
|
|
}
|
|
else
|
|
{
|
|
QNetworkServer.SpawnObjects();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal void RegisterClientMessages(QNetworkClient client)
|
|
{
|
|
client.RegisterHandler(QMsgType.Connect, OnClientConnectInternal);
|
|
client.RegisterHandler(QMsgType.Disconnect, OnClientDisconnectInternal);
|
|
client.RegisterHandler(QMsgType.NotReady, OnClientNotReadyMessageInternal);
|
|
client.RegisterHandler(QMsgType.Error, OnClientErrorInternal);
|
|
client.RegisterHandler(QMsgType.Scene, OnClientSceneInternal);
|
|
if (playerPrefab != null)
|
|
{
|
|
QClientScene.RegisterPrefab(playerPrefab);
|
|
}
|
|
foreach (var gameObject in spawnPrefabs)
|
|
{
|
|
if (gameObject != null)
|
|
{
|
|
QClientScene.RegisterPrefab(gameObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UseExternalClient(QNetworkClient externalClient)
|
|
{
|
|
if (runInBackground)
|
|
{
|
|
Application.runInBackground = true;
|
|
}
|
|
if (externalClient != null)
|
|
{
|
|
client = externalClient;
|
|
isNetworkActive = true;
|
|
RegisterClientMessages(client);
|
|
OnStartClient(client);
|
|
}
|
|
else
|
|
{
|
|
OnStopClient();
|
|
QClientScene.DestroyAllClientObjects();
|
|
QClientScene.HandleClientDisconnect(client.connection);
|
|
client = null;
|
|
if (!string.IsNullOrEmpty(offlineScene))
|
|
{
|
|
ClientChangeScene(offlineScene, false);
|
|
}
|
|
}
|
|
s_Address = networkAddress;
|
|
}
|
|
|
|
public QNetworkClient StartClient(ConnectionConfig config, int hostPort)
|
|
{
|
|
InitializeSingleton();
|
|
if (runInBackground)
|
|
{
|
|
Application.runInBackground = true;
|
|
}
|
|
isNetworkActive = true;
|
|
if (m_GlobalConfig != null)
|
|
{
|
|
NetworkTransport.Init(m_GlobalConfig);
|
|
}
|
|
client = new QNetworkClient
|
|
{
|
|
hostPort = hostPort
|
|
};
|
|
if (config != null)
|
|
{
|
|
if (config.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4 && Application.platform != RuntimePlatform.PSP2)
|
|
{
|
|
throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
|
|
}
|
|
client.Configure(config, 1);
|
|
}
|
|
else if (customConfig && m_ConnectionConfig != null)
|
|
{
|
|
m_ConnectionConfig.Channels.Clear();
|
|
foreach (var channel in channels)
|
|
{
|
|
m_ConnectionConfig.AddChannel(channel);
|
|
}
|
|
if (m_ConnectionConfig.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4 && Application.platform != RuntimePlatform.PSP2)
|
|
{
|
|
throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
|
|
}
|
|
client.Configure(m_ConnectionConfig, maxConnections);
|
|
}
|
|
RegisterClientMessages(client);
|
|
if (string.IsNullOrEmpty(networkAddress))
|
|
{
|
|
QLog.Error("Must set the Network Address field in the manager");
|
|
return null;
|
|
}
|
|
if (useSimulator)
|
|
{
|
|
client.ConnectWithSimulator(networkAddress, networkPort, simulatedLatency, packetLossPercentage);
|
|
}
|
|
else
|
|
{
|
|
client.Connect(networkAddress, networkPort);
|
|
}
|
|
OnStartClient(client);
|
|
s_Address = networkAddress;
|
|
return client;
|
|
}
|
|
|
|
public QNetworkClient StartClient() => StartClient(null);
|
|
|
|
public QNetworkClient StartClient(ConnectionConfig config) => StartClient(config, 0);
|
|
|
|
public virtual QNetworkClient StartHost(ConnectionConfig config, int maxConnections)
|
|
{
|
|
OnStartHost();
|
|
QNetworkClient result;
|
|
if (StartServer(config, maxConnections))
|
|
{
|
|
var networkClient = ConnectLocalClient();
|
|
OnServerConnect(networkClient.connection);
|
|
OnStartClient(networkClient);
|
|
result = networkClient;
|
|
}
|
|
else
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public virtual QNetworkClient StartHost()
|
|
{
|
|
OnStartHost();
|
|
QNetworkClient result;
|
|
if (StartServer())
|
|
{
|
|
var networkClient = ConnectLocalClient();
|
|
OnStartClient(networkClient);
|
|
result = networkClient;
|
|
}
|
|
else
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private QNetworkClient ConnectLocalClient()
|
|
{
|
|
QLog.Log($"NetworkManager StartHost port:{networkPort}");
|
|
networkAddress = "localhost";
|
|
client = QClientScene.ConnectLocalServer();
|
|
RegisterClientMessages(client);
|
|
return client;
|
|
}
|
|
|
|
public void StopHost()
|
|
{
|
|
OnStopHost();
|
|
StopClient();
|
|
StopServer();
|
|
}
|
|
|
|
public void StopServer()
|
|
{
|
|
if (QNetworkServer.active)
|
|
{
|
|
OnStopServer();
|
|
QLog.Log("NetworkManager StopServer");
|
|
isNetworkActive = false;
|
|
QNetworkServer.Shutdown();
|
|
if (!string.IsNullOrEmpty(offlineScene))
|
|
{
|
|
ServerChangeScene(offlineScene);
|
|
}
|
|
CleanupNetworkIdentities();
|
|
}
|
|
}
|
|
|
|
public void StopClient()
|
|
{
|
|
OnStopClient();
|
|
QLog.Log("NetworkManager StopClient");
|
|
isNetworkActive = false;
|
|
if (client != null)
|
|
{
|
|
client.Disconnect();
|
|
client.Shutdown();
|
|
client = null;
|
|
}
|
|
QClientScene.DestroyAllClientObjects();
|
|
if (!string.IsNullOrEmpty(offlineScene))
|
|
{
|
|
ClientChangeScene(offlineScene, false);
|
|
}
|
|
CleanupNetworkIdentities();
|
|
}
|
|
|
|
public virtual void ServerChangeScene(string newSceneName)
|
|
{
|
|
if (string.IsNullOrEmpty(newSceneName))
|
|
{
|
|
QLog.Error("ServerChangeScene empty scene name");
|
|
}
|
|
else
|
|
{
|
|
QLog.Log($"ServerChangeScene {newSceneName}");
|
|
QNetworkServer.SetAllClientsNotReady();
|
|
networkSceneName = newSceneName;
|
|
s_LoadingSceneAsync = SceneManager.LoadSceneAsync(newSceneName);
|
|
var msg = new QStringMessage(networkSceneName);
|
|
QNetworkServer.SendToAll(39, msg);
|
|
}
|
|
}
|
|
|
|
private void CleanupNetworkIdentities()
|
|
{
|
|
foreach (var networkIdentity in Resources.FindObjectsOfTypeAll<QNetworkIdentity>())
|
|
{
|
|
networkIdentity.MarkForReset();
|
|
}
|
|
}
|
|
|
|
internal void ClientChangeScene(string newSceneName, bool forceReload)
|
|
{
|
|
if (string.IsNullOrEmpty(newSceneName))
|
|
{
|
|
QLog.Error("ClientChangeScene empty scene name");
|
|
}
|
|
else
|
|
{
|
|
QLog.Log($"ClientChangeScene newSceneName:{newSceneName} networkSceneName:{networkSceneName}");
|
|
if (newSceneName == networkSceneName)
|
|
{
|
|
if (!forceReload)
|
|
{
|
|
FinishLoadScene();
|
|
return;
|
|
}
|
|
}
|
|
s_LoadingSceneAsync = SceneManager.LoadSceneAsync(newSceneName);
|
|
networkSceneName = newSceneName;
|
|
}
|
|
}
|
|
|
|
private void FinishLoadScene()
|
|
{
|
|
if (client != null)
|
|
{
|
|
if (s_ClientReadyConnection != null)
|
|
{
|
|
clientLoadedScene = true;
|
|
OnClientConnect(s_ClientReadyConnection);
|
|
s_ClientReadyConnection = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
QLog.Error("FinishLoadScene client is null");
|
|
}
|
|
if (QNetworkServer.active)
|
|
{
|
|
QNetworkServer.SpawnObjects();
|
|
OnServerSceneChanged(networkSceneName);
|
|
}
|
|
if (IsClientConnected() && client != null)
|
|
{
|
|
RegisterClientMessages(client);
|
|
OnClientSceneChanged(client.connection);
|
|
}
|
|
}
|
|
|
|
internal static void UpdateScene()
|
|
{
|
|
if (!(singleton == null))
|
|
{
|
|
if (s_LoadingSceneAsync != null)
|
|
{
|
|
if (s_LoadingSceneAsync.isDone)
|
|
{
|
|
QLog.Log($"ClientChangeScene done readyCon:{s_ClientReadyConnection}");
|
|
singleton.FinishLoadScene();
|
|
s_LoadingSceneAsync.allowSceneActivation = true;
|
|
s_LoadingSceneAsync = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsClientConnected() => client != null && client.isConnected;
|
|
|
|
public static void Shutdown()
|
|
{
|
|
if (!(singleton == null))
|
|
{
|
|
s_ClientReadyConnection = null;
|
|
singleton.StopHost();
|
|
singleton = null;
|
|
}
|
|
}
|
|
|
|
internal void OnServerConnectInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnServerConnectInternal");
|
|
netMsg.Connection.SetMaxDelay(maxDelay);
|
|
if (m_MaxBufferedPackets != 512)
|
|
{
|
|
for (var i = 0; i < QNetworkServer.numChannels; i++)
|
|
{
|
|
netMsg.Connection.SetChannelOption(i, ChannelOption.MaxPendingBuffers, m_MaxBufferedPackets);
|
|
}
|
|
}
|
|
if (!m_AllowFragmentation)
|
|
{
|
|
for (var j = 0; j < QNetworkServer.numChannels; j++)
|
|
{
|
|
netMsg.Connection.SetChannelOption(j, ChannelOption.AllowFragmentation, 0);
|
|
}
|
|
}
|
|
if (networkSceneName != "" && networkSceneName != offlineScene)
|
|
{
|
|
var msg = new QStringMessage(networkSceneName);
|
|
netMsg.Connection.Send(39, msg);
|
|
}
|
|
OnServerConnect(netMsg.Connection);
|
|
}
|
|
|
|
internal void OnServerDisconnectInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnServerDisconnectInternal");
|
|
OnServerDisconnect(netMsg.Connection);
|
|
}
|
|
|
|
internal void OnServerReadyMessageInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnServerReadyMessageInternal");
|
|
OnServerReady(netMsg.Connection);
|
|
}
|
|
|
|
internal void OnServerAddPlayerMessageInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnServerAddPlayerMessageInternal");
|
|
netMsg.ReadMessage(s_AddPlayerMessage);
|
|
if (s_AddPlayerMessage.msgSize != 0)
|
|
{
|
|
var extraMessageReader = new NetworkReader(s_AddPlayerMessage.msgData);
|
|
OnServerAddPlayer(netMsg.Connection, s_AddPlayerMessage.playerControllerId, extraMessageReader);
|
|
}
|
|
else
|
|
{
|
|
OnServerAddPlayer(netMsg.Connection, s_AddPlayerMessage.playerControllerId);
|
|
}
|
|
}
|
|
|
|
internal void OnServerRemovePlayerMessageInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnServerRemovePlayerMessageInternal");
|
|
netMsg.ReadMessage(s_RemovePlayerMessage);
|
|
netMsg.Connection.GetPlayerController(s_RemovePlayerMessage.PlayerControllerId, out var player);
|
|
OnServerRemovePlayer(netMsg.Connection, player);
|
|
netMsg.Connection.RemovePlayerController(s_RemovePlayerMessage.PlayerControllerId);
|
|
}
|
|
|
|
internal void OnServerErrorInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnServerErrorInternal");
|
|
netMsg.ReadMessage(s_ErrorMessage);
|
|
OnServerError(netMsg.Connection, s_ErrorMessage.errorCode);
|
|
}
|
|
|
|
internal void OnClientConnectInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnClientConnectInternal");
|
|
netMsg.Connection.SetMaxDelay(maxDelay);
|
|
var name = SceneManager.GetSceneAt(0).name;
|
|
if (string.IsNullOrEmpty(onlineScene) || onlineScene == offlineScene || name == onlineScene)
|
|
{
|
|
clientLoadedScene = false;
|
|
OnClientConnect(netMsg.Connection);
|
|
}
|
|
else
|
|
{
|
|
s_ClientReadyConnection = netMsg.Connection;
|
|
}
|
|
}
|
|
|
|
internal void OnClientDisconnectInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnClientDisconnectInternal");
|
|
if (!string.IsNullOrEmpty(offlineScene))
|
|
{
|
|
ClientChangeScene(offlineScene, false);
|
|
}
|
|
OnClientDisconnect(netMsg.Connection);
|
|
}
|
|
|
|
internal void OnClientNotReadyMessageInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnClientNotReadyMessageInternal");
|
|
QClientScene.SetNotReady();
|
|
OnClientNotReady(netMsg.Connection);
|
|
}
|
|
|
|
internal void OnClientErrorInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnClientErrorInternal");
|
|
netMsg.ReadMessage(s_ErrorMessage);
|
|
OnClientError(netMsg.Connection, s_ErrorMessage.errorCode);
|
|
}
|
|
|
|
internal void OnClientSceneInternal(QNetworkMessage netMsg)
|
|
{
|
|
QLog.Log("NetworkManager:OnClientSceneInternal");
|
|
var newSceneName = netMsg.Reader.ReadString();
|
|
if (IsClientConnected() && !QNetworkServer.active)
|
|
{
|
|
ClientChangeScene(newSceneName, true);
|
|
}
|
|
}
|
|
|
|
public virtual void OnServerConnect(QNetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
public virtual void OnServerDisconnect(QNetworkConnection conn)
|
|
{
|
|
QNetworkServer.DestroyPlayersForConnection(conn);
|
|
if (conn.LastError != NetworkError.Ok)
|
|
{
|
|
QLog.Error($"ServerDisconnected due to error: {conn.LastError}");
|
|
}
|
|
}
|
|
|
|
public virtual void OnServerReady(QNetworkConnection conn)
|
|
{
|
|
if (conn.PlayerControllers.Count == 0)
|
|
{
|
|
QLog.Warning("Ready with no player object");
|
|
}
|
|
QNetworkServer.SetClientReady(conn);
|
|
}
|
|
|
|
public virtual void OnServerAddPlayer(QNetworkConnection conn, short playerControllerId, NetworkReader extraMessageReader) => OnServerAddPlayerInternal(conn, playerControllerId);
|
|
|
|
public virtual void OnServerAddPlayer(QNetworkConnection conn, short playerControllerId) => OnServerAddPlayerInternal(conn, playerControllerId);
|
|
|
|
private void OnServerAddPlayerInternal(QNetworkConnection conn, short playerControllerId)
|
|
{
|
|
if (playerPrefab == null)
|
|
{
|
|
QLog.FatalError("The PlayerPrefab is empty on the QSBNetworkManager. Please setup a PlayerPrefab object.");
|
|
}
|
|
else if (playerPrefab.GetComponent<QNetworkIdentity>() == null)
|
|
{
|
|
QLog.FatalError("The PlayerPrefab does not have a QSBNetworkIdentity. Please add a QSBNetworkIdentity to the player prefab.");
|
|
}
|
|
else if (playerControllerId < conn.PlayerControllers.Count && conn.PlayerControllers[playerControllerId].IsValid && conn.PlayerControllers[playerControllerId].Gameobject != null)
|
|
{
|
|
QLog.Warning("There is already a player at that playerControllerId for this connections.");
|
|
}
|
|
else
|
|
{
|
|
var player = Instantiate(playerPrefab, Vector3.zero, Quaternion.identity);
|
|
QNetworkServer.AddPlayerForConnection(conn, player, playerControllerId);
|
|
}
|
|
}
|
|
|
|
public virtual void OnServerRemovePlayer(QNetworkConnection conn, QPlayerController player)
|
|
{
|
|
if (player.Gameobject != null)
|
|
{
|
|
QNetworkServer.Destroy(player.Gameobject);
|
|
}
|
|
}
|
|
|
|
public virtual void OnServerError(QNetworkConnection conn, int errorCode)
|
|
{
|
|
}
|
|
|
|
public virtual void OnServerSceneChanged(string sceneName)
|
|
{
|
|
}
|
|
|
|
public virtual void OnClientConnect(QNetworkConnection conn)
|
|
{
|
|
if (!clientLoadedScene)
|
|
{
|
|
QClientScene.Ready(conn);
|
|
if (autoCreatePlayer)
|
|
{
|
|
QClientScene.AddPlayer(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void OnClientDisconnect(QNetworkConnection conn)
|
|
{
|
|
StopClient();
|
|
if (conn.LastError != NetworkError.Ok)
|
|
{
|
|
QLog.Error($"ClientDisconnected due to error: {conn.LastError}");
|
|
}
|
|
}
|
|
|
|
public virtual void OnClientError(QNetworkConnection conn, int errorCode)
|
|
{
|
|
}
|
|
|
|
public virtual void OnClientNotReady(QNetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
public virtual void OnClientSceneChanged(QNetworkConnection conn)
|
|
{
|
|
QClientScene.Ready(conn);
|
|
if (autoCreatePlayer)
|
|
{
|
|
var flag = QClientScene.localPlayers.Count == 0;
|
|
var flag2 = false;
|
|
foreach (var player in QClientScene.localPlayers)
|
|
{
|
|
if (player.Gameobject != null)
|
|
{
|
|
flag2 = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
QClientScene.AddPlayer(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void OnStartHost()
|
|
{
|
|
}
|
|
|
|
public virtual void OnStartServer()
|
|
{
|
|
}
|
|
|
|
public virtual void OnStartClient(QNetworkClient client)
|
|
{
|
|
}
|
|
|
|
public virtual void OnStopServer()
|
|
{
|
|
}
|
|
|
|
public virtual void OnStopClient()
|
|
{
|
|
}
|
|
|
|
public virtual void OnStopHost()
|
|
{
|
|
}
|
|
}
|
|
} |