public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (GuyWithMovementNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("SyncMovementHistory", SyncMovementHistory, typeof(byte[])); MainThreadManager.Run(NetworkStart); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { ProcessOthers(gameObject.transform, obj.NetworkId + 1); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata == null) { return; } byte transformFlags = obj.Metadata[0]; if (transformFlags == 0) { return; } BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (NetworkAudioProfileNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("Attach", Attach, typeof(uint)); networkObject.RegisterRpc("Detach", Detach, typeof(uint)); networkObject.RegisterRpc("FetchSource", FetchSource, typeof(string), typeof(int)); networkObject.RegisterRpc("Play", Play, typeof(int)); networkObject.RegisterRpc("Pause", Pause); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { ProcessOthers(gameObject.transform, obj.NetworkId + 1); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (NodeServiceNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("RegisterNode", RegisterNode, typeof(uint)); networkObject.RegisterRpc("RegisterScene", RegisterScene, typeof(bool), typeof(byte[])); networkObject.RegisterRpc("UnregisterScene", UnregisterScene, typeof(bool), typeof(byte[])); networkObject.RegisterRpc("ConfirmScene", ConfirmScene, typeof(byte[])); networkObject.RegisterRpc("LookupScene", LookupScene, typeof(byte[])); networkObject.RegisterRpc("ReceiveLookupScene", ReceiveLookupScene, typeof(uint), typeof(byte[])); networkObject.RegisterRpc("RelayInstantiateInNode", RelayInstantiateInNode, typeof(byte[])); networkObject.RegisterRpc("InstantiateInNode", InstantiateInNode, typeof(byte[])); networkObject.RegisterRpc("RelayConfirmInstantiateInNode", RelayConfirmInstantiateInNode, typeof(byte[])); networkObject.RegisterRpc("ConfirmInstantiateInNode", ConfirmInstantiateInNode, typeof(byte[])); networkObject.RegisterRpc("RelayCreateNetworkSceneInNode", RelayCreateNetworkSceneInNode, typeof(byte[])); networkObject.RegisterRpc("CreateNetworkSceneInNode", CreateNetworkSceneInNode, typeof(byte[])); networkObject.RegisterRpc("RelayConfirmCreateNetworkSceneInNode", RelayConfirmCreateNetworkSceneInNode, typeof(byte[])); networkObject.RegisterRpc("ConfirmCreateNetworkSceneInNode", ConfirmCreateNetworkSceneInNode, typeof(byte[])); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (EntityNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("UpdateTeam", UpdateTeam, typeof(string)); networkObject.RegisterRpc("UpdateModule", UpdateModule, typeof(int), typeof(string), typeof(float), typeof(float), typeof(float), typeof(float), typeof(float), typeof(bool)); networkObject.RegisterRpc("UpdateHealth", UpdateHealth, typeof(float)); networkObject.RegisterRpc("UpdateShield", UpdateShield, typeof(float)); networkObject.RegisterRpc("UpdateMaxHealth", UpdateMaxHealth, typeof(float)); networkObject.RegisterRpc("UpdateMaxShield", UpdateMaxShield, typeof(float)); networkObject.RegisterRpc("UpdateAcceleration", UpdateAcceleration, typeof(float)); networkObject.RegisterRpc("UpdateSpeed", UpdateSpeed, typeof(float)); networkObject.RegisterRpc("UpdateAgility", UpdateAgility, typeof(float)); networkObject.RegisterRpc("UpdateVerticalInput", UpdateVerticalInput, typeof(int)); networkObject.RegisterRpc("UpdateHorizontalInput", UpdateHorizontalInput, typeof(int)); networkObject.RegisterRpc("UpdateName", UpdateName, typeof(string)); networkObject.RegisterRpc("Sync", Sync, typeof(float), typeof(Vector3), typeof(Quaternion), typeof(Vector3)); networkObject.RegisterRpc("Init", Init); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (PlayerNetworkObject)obj; networkObject.AttachedBehavior = this; /* * base.SetupHelperRpcs(networkObject); * networkObject.RegisterRpc("Shoot", Shoot, typeof(Vector3), typeof(Vector3)); * networkObject.RegisterRpc("Die", Die, typeof(string)); * networkObject.RegisterRpc("SwitchWeapon", SwitchWeapon, typeof(int)); * networkObject.RegisterRpc("TakeDamage", TakeDamage, typeof(int), typeof(Vector3), typeof(Vector3)); * networkObject.RegisterRpc("SetupPlayer", SetupPlayer, typeof(int), typeof(string)); */ networkObject.onDestroy += DestroyGameObject; ///if (!obj.IsOwner) if (networkObject.IsRemote) { if (!skipAttachIds.ContainsKey((uint)networkObject.frameSender.UID)) { ProcessOthers(gameObject.transform, (uint)networkObject.frameSender.UID + 1); } else { skipAttachIds.Remove((uint)networkObject.frameSender.UID); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); if (!networkObject.IsRemote) { networkObject.Networker.FlushCreateActions(networkObject); } }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (TowerNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("SignalEntry", SignalEntry, typeof(int)); networkObject.RegisterRpc("SignalExit", SignalExit, typeof(int)); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); bool changePos = (transformFlags & 0x01) != 0; bool changeRotation = (transformFlags & 0x02) != 0; if (changePos || changeRotation) { MainThreadManager.Run(() => { if (changePos) { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); } if (changeRotation) { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); } }); } } } MainThreadManager.Run(() => { gameObject.SetActive(true); NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (TestNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("FuncBlank", FuncBlank); networkObject.RegisterRpc("FuncByte", FuncByte, typeof(byte)); networkObject.RegisterRpc("FuncChar", FuncChar, typeof(char)); networkObject.RegisterRpc("FuncShort", FuncShort, typeof(short)); networkObject.RegisterRpc("FuncUShort", FuncUShort, typeof(ushort)); networkObject.RegisterRpc("FuncBool", FuncBool, typeof(bool)); networkObject.RegisterRpc("FuncInt", FuncInt, typeof(int)); networkObject.RegisterRpc("FuncUInt", FuncUInt, typeof(uint)); networkObject.RegisterRpc("FuncFloat", FuncFloat, typeof(float)); networkObject.RegisterRpc("FuncLong", FuncLong, typeof(long)); networkObject.RegisterRpc("FuncULong", FuncULong, typeof(ulong)); networkObject.RegisterRpc("FuncDouble", FuncDouble, typeof(double)); networkObject.RegisterRpc("FuncString", FuncString, typeof(string)); networkObject.RegisterRpc("FuncByteArray", FuncByteArray, typeof(byte[])); networkObject.RegisterRpc("FuncAll", FuncAll, typeof(byte), typeof(char), typeof(short), typeof(ushort), typeof(bool), typeof(int), typeof(uint), typeof(float), typeof(long), typeof(ulong), typeof(double), typeof(string), typeof(byte[])); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { ProcessOthers(gameObject.transform, obj.NetworkId + 1); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
/// <summary> /// Tells the client to change their scene to the given scene. This is often called /// after the server has changed to that scene to ensure that the server will always /// load up the scene before the client does /// </summary> /// <param name="netWorker">The current <see cref="NetWorker"/> that will be sending the message</param> /// <param name="targetPlayer">The particular player that will be receiving this message</param> /// <param name="sceneName">The name of the scene in which the client should load</param> public static void ChangeClientScene(NetWorker netWorker, NetworkingPlayer targetPlayer, string sceneName) { if (!netWorker.IsServer) throw new NetworkException("Only the server can call this method, the specified NetWorker is not a server"); BMSByte data = new BMSByte(); data.Clone(Encryptor.Encoding.GetBytes(sceneName)); data.InsertRange(0, new byte[1] { 2 }); netWorker.WriteRaw(targetPlayer, data); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (CubeForgeGameNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("InitializeMap", InitializeMap, typeof(Vector3), typeof(Vector3), typeof(byte[])); networkObject.RegisterRpc("CreatePrimitive", CreatePrimitive, typeof(byte), typeof(Vector3)); networkObject.RegisterRpc("DestroyPrimitive", DestroyPrimitive, typeof(Vector3)); networkObject.RegisterRpc("TestMe", TestMe, typeof(string)); MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata == null) { return; } byte transformFlags = obj.Metadata[0]; if (transformFlags == 0) { return; } BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (RPCPackagerNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("SendPackage", SendPackage, typeof(byte[])); networkObject.RegisterRpc("PlayerJoinedGame", PlayerJoinedGame, typeof(ushort), typeof(ushort), typeof(string), typeof(uint)); networkObject.RegisterRpc("UpdatePlayerName", UpdatePlayerName, typeof(ushort), typeof(ushort), typeof(string)); networkObject.RegisterRpc("PlayerLeftGame", PlayerLeftGame, typeof(ushort), typeof(ushort), typeof(uint)); networkObject.RegisterRpc("PlayerChangeTeams", PlayerChangeTeams, typeof(ushort), typeof(ushort)); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (PlayerNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("UpdateName", UpdateName, typeof(string)); networkObject.RegisterRpc("UpdatePing", UpdatePing, typeof(int)); networkObject.RegisterRpc("UpdateKills", UpdateKills, typeof(int)); networkObject.RegisterRpc("Shoot", Shoot, typeof(Vector3), typeof(Vector3)); networkObject.RegisterRpc("TakeDamage", TakeDamage, typeof(int), typeof(uint), typeof(Vector3), typeof(Vector3)); networkObject.RegisterRpc("UpdateId", UpdateId, typeof(uint)); networkObject.RegisterRpc("Spawn", Spawn, typeof(Vector3), typeof(Quaternion)); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { ProcessOthers(gameObject.transform, obj.NetworkId + 1); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
/// <summary> /// This method is used on the client to attempt to connect to the server through the NAT hole punch server /// </summary> /// <param name="socket">This is the socket that is being used for the communication with the server</param> /// <param name="port">This is the port number that this client is bound to</param> /// <param name="requestHost">This is the host address of the server that this client is trying to connect to</param> /// <param name="requestPort">This is the host port of the server that this client is trying to connect to</param> /// <param name="proxyHost">This is the NAT hole punch server host address</param> /// <param name="proxyPort">This is the NAT hole punch server port number</param> /// <returns></returns> public static bool RequestNat(CrossPlatformUDP socket, ushort port, string requestHost, ushort requestPort, string proxyHost, ushort proxyPort = PORT) { #if !NETFX_CORE IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse(proxyHost), proxyPort); List<byte> data = new List<byte>(new byte[] { 4, 4, 2 }); data.AddRange(BitConverter.GetBytes(port)); data.AddRange(BitConverter.GetBytes(requestPort)); data.AddRange(Encryptor.Encoding.GetBytes(requestHost)); try { int tryCount = 10; while (socket.ReadClient.Available == 0) { socket.ReadClient.Send(data.ToArray(), data.Count, endpoint); Thread.Sleep(500); if (--tryCount <= 0) throw new Exception("Unable to contact proxy host"); } string endpointStr = ""; BMSByte otherBytes = socket.ReadClient.Receive(ref endpoint, ref endpointStr); BMSByte found = new BMSByte(); found.Clone(otherBytes); if (found.byteArr[2] == 0) return false; ushort targetPort = System.BitConverter.ToUInt16(found.byteArr, 3); string targetHost = Encryptor.Encoding.GetString(found.byteArr, 5, found.byteArr.Length - 6); IPEndPoint targetEndpoint = new IPEndPoint(IPAddress.Parse(targetHost), targetPort); tryCount = 20; while (socket.ReadClient.Available == 0) { socket.ReadClient.Send(new byte[] { 4, 4, 0 }, 3, targetEndpoint); Thread.Sleep(500); if (--tryCount <= 0) throw new Exception("Unable to contact proxy host"); } #if UNITY_EDITOR Debug.Log("Connected via NAT traversal"); #endif } #if UNITY_EDITOR catch (Exception e) { Debug.LogException(e); } #else catch { } #endif #endif return true; }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (NetworkedPlayerNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("Attack", Attack); networkObject.RegisterRpc("ChangeName", ChangeName, typeof(string)); networkObject.RegisterRpc("Jump", Jump, typeof(bool)); networkObject.RegisterRpc("Land", Land); networkObject.RegisterRpc("Die", Die, typeof(string), typeof(int)); networkObject.RegisterRpc("TryHit", TryHit, typeof(uint), typeof(string), typeof(int), typeof(Vector3)); networkObject.RegisterRpc("Init", Init, typeof(int), typeof(Vector3)); networkObject.RegisterRpc("ToggleFlag", ToggleFlag, typeof(bool)); networkObject.RegisterRpc("Knockback", Knockback, typeof(Vector3)); networkObject.RegisterRpc("DebugAttack", DebugAttack); networkObject.RegisterRpc("Hitmarker", Hitmarker); networkObject.RegisterRpc("Respawn", Respawn); networkObject.RegisterRpc("Dash", Dash); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (MoveCube1NetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("MoveUp", MoveUp); networkObject.RegisterRpc("MoveDown", MoveDown); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { uint newId = obj.NetworkId + 1; ProcessOthers(gameObject.transform, ref newId); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
private static void Program1() { ConsoleBehavior obj = null; string serverIP = "127.0.0.1"; //string hostIP = "0.0.0.0"; //ushort port = NetWorker.DEFAULT_PORT; //ushort masterServerPort = 15940; //string natHost = "0.0.0.0"; BMSLog.Instance.RegisterLoggerService(new ConsoleLogger()); Console.Write("server or client: "); string serverOrClient = Console.ReadLine().ToLower(); if (serverOrClient == "client" || serverOrClient == "c") { networkHandle = new TCPClient(); ((TCPClient)networkHandle).Connect(serverIP /*, port*/); } else if (serverOrClient == "server" || serverOrClient == "s") { networkHandle = new TCPServer(32); ((TCPServer)networkHandle).Connect(); //RegisterOnMasterServer(networkHandle, 32, serverIP, masterServerPort); } //if (serverOrClient == "client" || serverOrClient == "c") //{ // networkHandle = new UDPClient(); // ((UDPClient)networkHandle).Connect(serverIP/*, port, natHost*/); //} //else if (serverOrClient == "server" || serverOrClient == "s") //{ // networkHandle = new UDPServer(32); // ((UDPServer)networkHandle).Connect(/*hostIP, port, natHost*/); //} else { Console.WriteLine("Invalid"); return; } networkHandle.textMessageReceived += ReadTextMessage; networkHandle.binaryMessageReceived += ReadBinaryMessage; NetworkObject.Factory = new NetworkObjectFactory(); networkHandle.objectCreated += (NetworkObject target) => { if (target is ConsoleNetworkObject) { obj = new ConsoleDerivedNetworkObject(); obj.Initialize(target); } }; networkHandle.serverAccepted += (sender) => { if (networkHandle is IClient) { new ConsoleNetworkObject(networkHandle); } }; while (true) { Console.Write("Enter a message: "); string message = Console.ReadLine(); if (message == "disconnect") { networkHandle.Disconnect(false); } else if (message == "exit") { break; } else if (message == "file") { BMSByte data = new BMSByte(); data.Clone(System.IO.File.ReadAllBytes("testSend.txt")); data.InsertRange(0, new byte[1] { 212 }); if (networkHandle is TCPServer) { ((TCPServer)networkHandle).SendAll(new Binary(networkHandle.Time.Timestep, false, data, Receivers.All, 55, true)); } else if (networkHandle is TCPClient) { ((TCPClient)networkHandle).Send(new Binary(networkHandle.Time.Timestep, true, data, Receivers.All, 55, true)); } else if (networkHandle is BaseUDP) { ((BaseUDP)networkHandle).Send(new Binary(networkHandle.Time.Timestep, false, data, Receivers.All, 55, false), false); } } else if (message == "rpc") { obj.networkObject.SendRpc(ConsoleBehavior.RPC_HELLO_WORLD, Receivers.AllBuffered, null, "World!"); } else if (message.StartsWith("set num to ")) { obj.networkObject.Num = int.Parse(message.Substring("set name to ".Length)); } else if (message == "num") { Console.WriteLine("Number is currently " + obj.networkObject.Num); } else { if (networkHandle is TCPServer) { obj.networkObject.SendRpc(ConsoleBehavior.RPC_HELLO_WORLD, Receivers.Others, message); } // ((TCPServer)networkHandle).SendAll(Text.CreateFromString(networkHandle.Time.Timestep, message, false, Receivers.All, 55, true)); else if (networkHandle is TCPClient) { ((TCPClient)networkHandle).Send(Text.CreateFromString(networkHandle.Time.Timestep, message, true, Receivers.All, 55, true)); } else if (networkHandle is BaseUDP) { ((BaseUDP)networkHandle).Send(Text.CreateFromString(networkHandle.Time.Timestep, message, false, Receivers.All, 55, false), true); } } } }
public async void ConnectAndRead(string hostAddress, ushort port, NetworkingStream stream) { try { serverHost = new HostName(hostAddress); // Try to connect asynchronously await socket.ConnectAsync(serverHost, port.ToString()); Connected = true; OnConnected(); SendAsync(stream); byte[] bytes = null; Task tReadResponse = Task.Run(async () => { DataReader reader = new DataReader(socket.InputStream); uint messageSize = await reader.LoadAsync(sizeof(uint)); if (messageSize != sizeof(uint)) { Disconnect(); // socket was closed return; } bytes = new byte[messageSize]; reader.ReadBytes(bytes); messageSize = BitConverter.ToUInt32(bytes, 0); await reader.LoadAsync(messageSize); bytes = new byte[messageSize]; // TODO: This may read the first 4 bytes again for the size, make sure it doesn't reader.ReadBytes(bytes); }); tReadResponse.Wait(); Disconnect(); BMSByte tmp = new BMSByte(); tmp.Clone(bytes); //return new NetworkingStream(Networking.ProtocolType.TCP).Consume(this, null, tmp); } catch (Exception e) { ErrorDisconnect(e.Message); } }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (PlayerCharacterNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("SendInputs", SendInputs, typeof(ulong), typeof(Vector3), typeof(Quaternion)); networkObject.RegisterRpc("StartGame", StartGame); networkObject.RegisterRpc("FireWeapon", FireWeapon, typeof(ulong), typeof(byte), typeof(Vector3), typeof(Vector3)); networkObject.RegisterRpc("WeaponFired", WeaponFired, typeof(ulong), typeof(byte)); networkObject.RegisterRpc("SetLocalPlayerId", SetLocalPlayerId, typeof(uint)); networkObject.RegisterRpc("Die", Die, typeof(uint)); networkObject.RegisterRpc("WeaponImpacted", WeaponImpacted, typeof(ulong), typeof(byte), typeof(long), typeof(Vector3)); networkObject.RegisterRpc("Kill", Kill, typeof(uint)); networkObject.RegisterRpc("UpdatePosition", UpdatePosition, typeof(ulong), typeof(Vector3), typeof(Quaternion), typeof(Vector3)); networkObject.RegisterRpc("SendInputBuffer", SendInputBuffer, typeof(uint), typeof(byte[])); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { ProcessOthers(gameObject.transform, obj.NetworkId + 1); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }
/// <summary> /// Tells the client to change their scene to the given scene. This is often called /// after the server has changed to that scene to ensure that the server will always /// load up the scene before the client does /// </summary> /// <param name="port">The port of the <see cref="NetWorker"/> that is to send the message</param> /// <param name="targetPlayer">The particular player that will be receiving this message</param> /// <param name="sceneName">The name of the scene in which the client should load</param> public static void ChangeClientScene(ushort port, NetworkingPlayer targetPlayer, string sceneName) { if (!Sockets.ContainsKey(port)) throw new NetworkException("There isn't a server running using the specified port on this machine"); if (!Sockets[port].IsServer) throw new NetworkException("Writing to particular players can only be done by the server, the NetWorker on the specified port is not a server"); BMSByte data = new BMSByte(); data.Clone(Encryptor.Encoding.GetBytes(sceneName)); data.InsertRange(0, new byte[1] { 2 }); Sockets[port].WriteRaw(data, false); }
public override void Initialize(NetworkObject obj) { // We have already initialized this object if (networkObject != null && networkObject.AttachedBehavior != null) { return; } networkObject = (MasterNetworkObject)obj; networkObject.AttachedBehavior = this; base.SetupHelperRpcs(networkObject); networkObject.RegisterRpc("SendMessage", SendMessage, typeof(string)); networkObject.RegisterRpc("AddActivePlayer", AddActivePlayer, typeof(string), typeof(bool)); networkObject.RegisterRpc("RemoveActivePlayer", RemoveActivePlayer, typeof(string)); networkObject.RegisterRpc("ClientLoadMothership", ClientLoadMothership, typeof(string)); networkObject.RegisterRpc("StartTravel", StartTravel, typeof(string)); networkObject.RegisterRpc("CheckTravel", CheckTravel); networkObject.RegisterRpc("EnterOrbit", EnterOrbit, typeof(int)); networkObject.RegisterRpc("LeaveOrbit", LeaveOrbit); networkObject.RegisterRpc("ColonizePlanet", ColonizePlanet); networkObject.RegisterRpc("CanColonize", CanColonize); networkObject.RegisterRpc("LandOnPlanet", LandOnPlanet); networkObject.RegisterRpc("CanLandOnPlanet", CanLandOnPlanet); networkObject.RegisterRpc("ClientEnterOrbit", ClientEnterOrbit); networkObject.RegisterRpc("SendCallbackToClient", SendCallbackToClient, typeof(string), typeof(bool), typeof(string)); networkObject.RegisterRpc("SendEventTrigger", SendEventTrigger, typeof(string), typeof(bool)); networkObject.RegisterRpc("CalculateTravelTime", CalculateTravelTime, typeof(int), typeof(bool)); networkObject.RegisterRpc("SendBmcRequest", SendBmcRequest, typeof(string), typeof(string)); networkObject.RegisterRpc("SendBmcCallbackToClient", SendBmcCallbackToClient, typeof(string), typeof(string)); networkObject.RegisterRpc("StartMiningMission", StartMiningMission, typeof(byte), typeof(byte), typeof(byte), typeof(bool)); networkObject.RegisterRpc("LogBook", LogBook, typeof(int), typeof(string)); networkObject.onDestroy += DestroyGameObject; if (!obj.IsOwner) { if (!skipAttachIds.ContainsKey(obj.NetworkId)) { ProcessOthers(gameObject.transform, obj.NetworkId + 1); } else { skipAttachIds.Remove(obj.NetworkId); } } if (obj.Metadata != null) { byte transformFlags = obj.Metadata[0]; if (transformFlags != 0) { BMSByte metadataTransform = new BMSByte(); metadataTransform.Clone(obj.Metadata); metadataTransform.MoveStartIndex(1); if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } else if ((transformFlags & 0x01) != 0) { MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); }); } else if ((transformFlags & 0x02) != 0) { MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); }); } } } MainThreadManager.Run(() => { NetworkStart(); networkObject.Networker.FlushCreateActions(networkObject); }); }