public override void OnRPCCommand(NetworkPlayer player, string command) { base.OnRPCCommand(player, command); NetworkRPC rpc = NetworkRPC.FromString(command); switch (rpc.m_Type) { case NetworkRPCType.RPC_CUSTOM_PLAYER: { NetworkPlayerRPC playerRPC = NetworkRPC.Parse <NetworkPlayerRPC>(command); GameObject obj = NetworkManager.Instance.GetNetworkedObject(playerRPC.m_NetworkId); if (PlayerHasAuthority(obj, player)) { if (playerRPC.m_Health != -1) { ELogger.Log($"{playerRPC.m_NetworkId} is trying to edit their health to {playerRPC.m_Health}!", ELogger.LogType.Server); break; } playerRPC.m_Health = obj.GetComponent <Player>().m_Health; // Set it to the server health obj.GetComponent <Player>().UpdateColor(playerRPC.m_Color); UpdateRPC(obj, playerRPC); SendRPCAll(playerRPC); } } break; } }
public void Destroy() { ELogger.Log($"Cleaning up", ELogger.LogType.Server); StopAllCoroutines(); CancelInvoke(); NetworkManager.Instance.Clean(); Destroy(this); }
public void ErrorMessageBoxShow(Exception ex) { var e = Functions.GetLastChildException(ex); Dispatcher.Invoke((Action)(() => { MessageBox.Show(e.Message, "友情提示", MessageBoxButton.OK, MessageBoxImage.Error); })); ELogger.Debug(e); }
public void Clean() { if (NetworkManager.Instance.IsMixed()) { return; } ELogger.Log("Cleaning up client", ELogger.LogType.Client); if (NetworkManager.Instance.IsClient()) { NetworkManager.Instance.Clean(); } Destroy(this); }
public override void OnConnectionShutdown(NetworkShutdownType type, string reason) { base.OnConnectionShutdown(type, reason); ELogger.Log($"Server stopped for reason '{reason}' with type {type}", ELogger.LogType.Server); if (NetworkManager.Instance != null) { NetworkManager.Instance.m_IsPlaying = false; foreach (NetworkPlayer player in NetworkManager.Instance.GetPlayers()) { RemovePlayer(player, "Server Stopping", NetworkDisconnectType.ServerStopped, true); } } Destroy(); }
// TODO: Clean this function up, its not pretty private void Initialize(string id, bool client = false, bool proxy = false, int port = 0, string address = "") { if (id == "server") { m_IsServer = true; } m_ProcessBuffer = new Queue <DataChunk>(); m_SendBuffer = new Queue <SendChunk>(); m_Endpoints = new Dictionary <string, IPEndPoint>(); m_ReceiveThread = new Thread(new ThreadStart(ReceiveWorker)); m_SendThread = new Thread(new ThreadStart(SendWorker)); m_Running = true; if (client || proxy) { m_Client = new UdpClient(); ELogger.Log($"Connecting to proxy/server at {address}:{port}", ELogger.LogType.Normal); m_Client.Connect(address, port); StartCoroutine(TryConnect(id)); } else { try { ELogger.Log($"Establishing server on port {port}", ELogger.LogType.Server); m_Client = new UdpClient(port); m_NetworkState = NetworkState.Established; OnConnectionEstablished(); } catch (SocketException) { OnConnectionError(NetworkError.CrowdedPort); return; } } m_ReceiveThread.Start(); m_SendThread.Start(); InvokeRepeating("ProcessWorker", 0, 0.001f); }
/// <summary> /// A function that attempts to connect to a server if given the ip and port /// </summary> private IEnumerator TryConnect(string senderId) { while (m_NetworkState != NetworkState.Established && m_Tries != 5) { ELogger.Log($"Attempting to establish connection: [{m_Tries + 1}/5]", ELogger.LogType.Client); QueueFrame(new NetworkAuthenticationFrame("", senderId, "proxy")); m_Tries++; yield return(new WaitForSeconds(2.5f)); } if (m_NetworkState == NetworkState.Established) { ELogger.Log("Network connection established", ELogger.LogType.Client); OnConnectionEstablished(); } else { OnConnectionError(NetworkError.ConnectionFailed); } }
/// <summary> /// Initializes any networked objects that were already in the scene /// </summary> private void InitializeNetworkedObjects() { NetworkBehaviour[] networkObjects = FindObjectsOfType <NetworkBehaviour>(); foreach (NetworkBehaviour behaviour in networkObjects) { NetworkIdentity identity = behaviour.GetComponent <NetworkIdentity>(); if (identity == null) { continue; } if (NetworkManager.Instance.GetNetworkedObject(identity.m_NetworkId) != null) { continue; } AddObjectToNetwork(behaviour.gameObject); NetworkObjectServerInfo serverInfo = behaviour.gameObject.AddComponent <NetworkObjectServerInfo>(); serverInfo.m_PrefabIndex = -2; // Lets "spawn" the object on our side real fast ELogger.Log($"Spawning pre-existing networked object: {behaviour.gameObject.name}", ELogger.LogType.Server); } }
public override void OnConnectionError(NetworkError error) { base.OnConnectionError(error); ELogger.Log($"Server errored with error '{error}'", ELogger.LogType.Server); }
/// <summary> /// Called when a player has disconnected from the server /// </summary> /// <param name="player">The player that was disconnected</param> /// <param name="type">The type of disconnection it was</param> /// <param name="reason">The reason the player was disconnected</param> public virtual void OnPlayerDisconnected(NetworkPlayer player, NetworkDisconnectType type, string reason) { ELogger.Log($"A player has disconnected from the server: {player.m_Name}|{type}|{reason}", ELogger.LogType.Server); }
/// <summary> /// Called when a player connects to the server /// </summary> /// <param name="player">The player that has connected</param> public virtual void OnPlayerConnected(NetworkPlayer player) { ELogger.Log($"A player has connected to the server: {player.m_Name}|{player.m_Id}", ELogger.LogType.Server); }
public static ILog GetLogger(ELogger logger) { return(Loggers[logger]); }
protected ServiceBase(ELogger logger = ELogger.Common) { Log = LoggerFactory.GetLogger(logger); }
/// <summary> /// Send a RPC command to a specified network id /// </summary> /// <param name="rpc">The RPC being sent throughout the network</param> public void OnRPCCommand(string content) { NetworkRPC rpc = NetworkRPC.FromString(content); switch (rpc.m_Type) // If a type is handled here its because it needs to be here, or the networking wont function properly { case NetworkRPCType.RPC_LIB_SPAWN: { if (NetworkManager.Instance.IsMixed()) { break; // We already have it spawned for us } NetworkSpawnRPC spawnRPC = NetworkRPC.Parse <NetworkSpawnRPC>(content); if (NetworkManager.Instance.GetNetworkedObject(spawnRPC.m_NetworkId) != null) { break; } GameObject spawnPrefab = NetworkManager.Instance.GetObjectByIndex(spawnRPC.m_PrefabIndex); if (spawnPrefab == null) { break; } GameObject prefab = Instantiate(spawnPrefab); NetworkBehaviour networkBehaviour = prefab.GetComponent <NetworkBehaviour>(); networkBehaviour.m_IsServer = false; networkBehaviour.m_HasAuthority = false; networkBehaviour.m_IsClient = true; prefab.GetComponent <NetworkIdentity>().m_NetworkId = spawnRPC.m_NetworkId; NetworkManager.Instance.AddObject(spawnRPC.m_NetworkId, prefab); } break; case NetworkRPCType.RPC_LIB_OBJECT_NETAUTH: { NetworkAuthorizationRPC authorizationRPC = NetworkRPC.Parse <NetworkAuthorizationRPC>(content); GameObject gameObject = NetworkManager.Instance.GetNetworkedObject(authorizationRPC.m_NetworkId); if (gameObject != null) { NetworkBehaviour networkBehaviour = gameObject.GetComponent <NetworkBehaviour>(); networkBehaviour.m_IsClient = authorizationRPC.m_LocalSet; networkBehaviour.m_HasAuthority = authorizationRPC.m_LocalAuthSet; networkBehaviour.m_IsServer = authorizationRPC.m_ServerSet; gameObject.GetComponent <NetworkIdentity>().m_NetworkId = authorizationRPC.m_NetworkId; networkBehaviour.OnAuthorityChanged(networkBehaviour.m_HasAuthority); } } break; case NetworkRPCType.RPC_LIB_DESTROY: { GameObject gameObject = NetworkManager.Instance.GetNetworkedObject(rpc.m_NetworkId); if (gameObject != null) { Destroy(gameObject); } } break; case NetworkRPCType.RPC_LIB_TRANSFORM: { if (NetworkManager.Instance.IsMixed()) { break; // We are sort of server, so we have most up to date value } NetworkTransformRPC transformRPC = NetworkRPC.Parse <NetworkTransformRPC>(content); GameObject obj = NetworkManager.Instance.GetNetworkedObject(rpc.m_NetworkId); if (obj != null) { obj.transform.position = transformRPC.m_Position; obj.transform.eulerAngles = transformRPC.m_Rotation; obj.transform.localScale = transformRPC.m_Scale; } } break; case NetworkRPCType.RPC_LIB_CONNECTED: { NetworkPlayerConnectRPC connectRPC = NetworkRPC.Parse <NetworkPlayerConnectRPC>(content); ELogger.Log($"Player Connected: {connectRPC.m_Player.m_Name}", ELogger.LogType.Client); NetworkManager.Instance.AddPlayer(connectRPC.m_Player.m_Id, connectRPC.m_Player); foreach (var networkPair in NetworkManager.Instance.GetNetworkedObjects()) { if (networkPair.Value != null) { NetworkBehaviour networkBehaviour = networkPair.Value.GetComponent <NetworkBehaviour>(); if (networkBehaviour != null) { networkBehaviour.OnPlayerJoined(connectRPC.m_Player); } } } } break; case NetworkRPCType.RPC_LIB_DISCONNECTED: { NetworkPlayerDisconnctRPC disconnectRPC = NetworkRPC.Parse <NetworkPlayerDisconnctRPC>(content); NetworkManager.Instance.RemovePlayer(disconnectRPC.m_Player.m_Id); foreach (var networkPair in NetworkManager.Instance.GetNetworkedObjects()) { if (networkPair.Value != null) { NetworkBehaviour networkBehaviour = networkPair.Value.GetComponent <NetworkBehaviour>(); if (networkBehaviour != null) { networkBehaviour.OnPlayerDisconnected(disconnectRPC.m_Player, disconnectRPC.m_DisconnectType, disconnectRPC.m_Reason); } } } if (disconnectRPC.m_Player.m_Id == GetUniqueIndentifier()) { ELogger.Log($"We were disconnected for reason '{disconnectRPC.m_Reason}' with type {disconnectRPC.m_Type}|{disconnectRPC.m_DisconnectType}", ELogger.LogType.Client); Clean(); UnityEditor.EditorApplication.isPlaying = false; } else { ELogger.Log($"Player Disonnected: {disconnectRPC.m_Player.m_Name}", ELogger.LogType.Client); } } break; default: { GameObject obj = NetworkManager.Instance.GetNetworkedObject(rpc.m_NetworkId); if (obj != null) { NetworkBehaviour behaviour = obj.GetComponent <NetworkBehaviour>(); if (behaviour != null) { behaviour.OnRPCCommand(content); } } } break; } }