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