void SendTransform() { if ((timeLastBuffering >= bufferingPeriod)&&((lastAnimation!="idle")||(currentAnimation!="idle"))) {//&&(lastAnimation.Equals("idle")) lastState = NetworkTransform.FromTransform(thisTransform); SFSObject data=new SFSObject(); if (!currentAnimation.Equals(lastAnimation)) data.PutUtfString("anim",currentAnimation); lastState.ToSFSObject(data); buffer.AddSFSObject(data); timeLastSending += bufferingPeriod; packageSize+=1; timeLastBuffering = 0.0f; lastAnimation=currentAnimation; //return; } else if (!packageSize.Equals(0)){ sendBuffer(); packageSize=0; } if (packageSize.Equals(packageMaxSize)){ sendBuffer(); packageSize=0; //timeLastSending = 0.0f; } timeLastBuffering += Time.deltaTime; }
// Creating NetworkTransform from SFS object public static NetworkTransform FromSFSObject(ISFSObject data) { NetworkTransform trans = new NetworkTransform(); ISFSObject transformData = data.GetSFSObject("transform"); float x = Convert.ToSingle(transformData.GetDouble("x")); float y = Convert.ToSingle(transformData.GetDouble("y")); float z = Convert.ToSingle(transformData.GetDouble("z")); float rx = Convert.ToSingle(transformData.GetDouble("rx")); float ry = Convert.ToSingle(transformData.GetDouble("ry")); float rz = Convert.ToSingle(transformData.GetDouble("rz")); trans.position = new Vector3(x, y, z); trans.angleRotation = new Vector3(rx, ry, rz); if (transformData.ContainsKey("t")) { trans.TimeStamp = Convert.ToDouble(transformData.GetLong("t")); } else { trans.TimeStamp = 0; } return(trans); }
private void SpawnLocalPlayer(int numModel, NetworkTransform trans) { Vector3 pos; Vector3 rot; // See if there already exists a model - if so, take its pos+rot before destroying it if (localPlayer != null) { pos = localPlayer.transform.position; rot = localPlayer.transform.localEulerAngles; // Camera.main.transform.parent = null; Destroy(localPlayer); } else { pos = trans.Position; rot = trans.AngleRotationFPS; } // Lets spawn our local player model localPlayer = GameObject.Instantiate(playerModels[0]) as GameObject; localPlayer.transform.position = pos; localPlayer.transform.localEulerAngles = rot; localPlayer.AddComponent <NetworkTransformSender>(); //localPlayer.SendMessage ("StratSendTransform"); NetworkTransformSender.Instance.StartSendTransform(); SendCheckAuctionStart(); // }
public void ReceivedTransform(NetworkTransform ntransform) { if (!running) { return; } // When receiving, buffer the information // Receive latest state information //Vector3 pos = ntransform.Position; // Quaternion rot = ntransform.Rotation; // Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1 for (int i = bufferedStates.Length - 1; i >= 1; i--) { bufferedStates[i] = bufferedStates[i - 1]; } // Save currect received state as 0 in the buffer, safe to overwrite after shifting bufferedStates[0] = ntransform; // Increment state count but never exceed buffer size statesCount = Mathf.Min(statesCount + 1, bufferedStates.Length); // Check integrity, lowest numbered state in the buffer is newest and so on for (int i = 0; i < statesCount - 1; i++) { if (bufferedStates[i].TimeStamp < bufferedStates[i + 1].TimeStamp) { Debug.Log("State inconsistent"); } } }
void Start() { rb = GetComponent <Rigidbody2D>(); networkTransform = GetComponent <NetworkTransform>(); spawner = FindObjectOfType <WaterBalloonSpawner>(); rb.AddForce(movePosition); }
void Start() { if (this.GetComponent <NetworkIdentity>() == null) { networkIdentity = this.gameObject.AddComponent <NetworkIdentity>(); } else { networkIdentity = this.gameObject.GetComponent <NetworkIdentity>(); } networkIdentity.localPlayerAuthority = false; if (this.GetComponent <NetworkTransform>() == null) { networkTransform = this.gameObject.AddComponent <NetworkTransform>(); } else { networkTransform = this.gameObject.GetComponent <NetworkTransform>(); } networkTransform.sendInterval = 0.005f; this.tag = TAG; if (_typeInt != 0) { SetAsteroidType(Type); } }
void GetNetworkInformation(GameObject gameObject) { m_Transform = gameObject.GetComponent <NetworkTransform>(); m_Rigidbody3D = gameObject.GetComponent <Rigidbody>(); m_Rigidbody2D = gameObject.GetComponent <Rigidbody2D>(); }
public void ReceiveTransform(NetworkTransform nTransform) { //if (interpolator!=null) { // interpolating received transform interpolator.ReceivedTransform(nTransform); //lastBoneTransformRotation = boneTransformRotation; //boneTransformRotation = nTransform.rotationBone; //lastMovementTransformRotation = movementTransformRotation; //movementTransformRotation = nTransform.rotationMovement; } /*else * { * //lastMovementTransformRotation = movementTransformRotation; * movementTransformRotation = nTransform.rotationMovement; * * //lastBoneTransformRotation = boneTransformRotation; * boneTransformRotation = nTransform.rotationBone; * * myTransform.position = nTransform.position; * myTransform.localRotation = nTransform.rotation; * movementTransform.localRotation = nTransform.rotationMovement; * boneTransform.localRotation = nTransform.rotationBone; * }*/ }
public void ReceivedTransform(NetworkTransform ntransform) { if (!running) return; // Shift the buffer sideways, deleting state 20 for (int i=m_BufferedState.Length-1;i>=1;i--) { m_BufferedState[i] = m_BufferedState[i-1]; } // Record current state in slot 0 m_BufferedState[0] = ntransform; // Update used slot count, however never exceed the buffer size // Slots aren't actually freed so this just makes sure the buffer is // filled up and that uninitalized slots aren't used. m_TimestampCount = Mathf.Min(m_TimestampCount + 1, m_BufferedState.Length); // Check if states are in order, if it is inconsistent you could reshuffel or // drop the out-of-order state. Nothing is done here for (int i=0;i<m_TimestampCount-1;i++) { if (m_BufferedState[i].TimeStamp < m_BufferedState[i+1].TimeStamp) Debug.Log("State inconsistent"); } }
public static NetworkTransform FromSFSObject(ISFSObject data) { NetworkTransform trans = new NetworkTransform(); ISFSObject transformData = data.GetSFSObject("transform"); float x = Convert.ToSingle(transformData.GetDouble("x")); float y = Convert.ToSingle(transformData.GetDouble("y")); float z = Convert.ToSingle(transformData.GetDouble("z")); float rx = Convert.ToSingle(transformData.GetDouble("rx")); float ry = Convert.ToSingle(transformData.GetDouble("ry")); float rz = Convert.ToSingle(transformData.GetDouble("rz")); trans.position = new Vector3(x, y, z); trans.angleRotation = new Vector3(rx, ry, rz); if (transformData.ContainsKey("t")) { trans.TimeStamp = Convert.ToDouble(transformData.GetLong("t")); } else { trans.TimeStamp = 0; } return trans; }
private void Awake() { SpriteRenderer = GetComponent <SpriteRenderer>(); Body = GetComponent <Rigidbody2D>(); OwnCollider = GetComponent <Collider2D>(); NetworkTransform = GetComponent <NetworkTransform>(); }
public void ReceivedTransform(NetworkTransform ntransform) { if (!running) return; // When receiving, buffer the information // Receive latest state information Vector3 pos = ntransform.Position; Quaternion rot = ntransform.Rotation; // Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1 for ( int i=bufferedStates.Length-1;i>=1;i-- ) { bufferedStates[i] = bufferedStates[i-1]; } // Save currect received state as 0 in the buffer, safe to overwrite after shifting bufferedStates[0] = ntransform; // Increment state count but never exceed buffer size statesCount = Mathf.Min(statesCount + 1, bufferedStates.Length); // Check integrity, lowest numbered state in the buffer is newest and so on for (int i=0; i<statesCount-1; i++) { if (bufferedStates[i].TimeStamp < bufferedStates[i+1].TimeStamp) { Debug.Log("State inconsistent"); } } }
public void Init() { if (m_Initialized) { return; } m_Initialized = true; m_SyncTransform = target as NetworkTransform; if (m_SyncTransform.transformSyncMode == NetworkTransform.TransformSyncMode.SyncNone) { if (m_SyncTransform.GetComponent <Rigidbody>() != null) { m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncRigidbody3D; m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ; EditorUtility.SetDirty(m_SyncTransform); } else if (m_SyncTransform.GetComponent <Rigidbody2D>() != null) { m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncRigidbody2D; m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisZ; EditorUtility.SetDirty(m_SyncTransform); } else if (m_SyncTransform.GetComponent <CharacterController>() != null) { m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncCharacterController; m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ; EditorUtility.SetDirty(m_SyncTransform); } else { m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncTransform; m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ; EditorUtility.SetDirty(m_SyncTransform); } } m_TransformSyncMode = serializedObject.FindProperty("m_TransformSyncMode"); m_MovementTheshold = serializedObject.FindProperty("m_MovementTheshold"); m_VelocityThreshold = serializedObject.FindProperty("m_VelocityThreshold"); m_SnapThreshold = serializedObject.FindProperty("m_SnapThreshold"); m_InterpolateRotation = serializedObject.FindProperty("m_InterpolateRotation"); m_InterpolateMovement = serializedObject.FindProperty("m_InterpolateMovement"); m_RotationSyncCompression = serializedObject.FindProperty("m_RotationSyncCompression"); m_SyncSpin = serializedObject.FindProperty("m_SyncSpin"); m_NetworkSendIntervalProperty = serializedObject.FindProperty("m_SendInterval"); m_NetworkSendIntervalLabel = new GUIContent("Network Send Rate (seconds)", "Number of network updates per second"); EditorGUI.indentLevel += 1; m_MovementThesholdLabel = new GUIContent("Movement Threshold"); m_VelocityThresholdLabel = new GUIContent("Velocity Threshold"); m_SnapThresholdLabel = new GUIContent("Snap Threshold"); m_InterpolateRotationLabel = new GUIContent("Interpolate Rotation Factor"); m_InterpolateMovementLabel = new GUIContent("Interpolate Movement Factor"); m_RotationSyncCompressionLabel = new GUIContent("Compress Rotation"); m_SyncSpinLabel = new GUIContent("Sync Angular Velocity"); EditorGUI.indentLevel -= 1; }
public void Stop() { NavMeshAgent agent = this.ownerUnit.GetComponent <NavMeshAgent>(); if (agent != null) { agent.Stop(); agent.ResetPath(); } agent = this.mergingUnit.GetComponent <NavMeshAgent>(); if (agent != null) { agent.Stop(); agent.ResetPath(); } Collider collider = this.ownerUnit.GetComponent <Collider>(); if (collider != null) { collider.enabled = false; } NetworkTransform transform = this.ownerUnit.GetComponent <NetworkTransform>(); if (transform != null) { transform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncNone; } transform = this.mergingUnit.GetComponent <NetworkTransform>(); if (transform != null) { transform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncNone; } }
// Clone itself public static NetworkTransform Clone(NetworkTransform ntransform) { NetworkTransform trans = new NetworkTransform(); trans.Load(ntransform); return(trans); }
private void Start() { networkTransform = new NetworkTransform(transform); networkRigidbody = new NetworkRigidbody2D(GetComponent <Rigidbody2D>()); SendPayload = new NetworkCommand <Action <string, int> >(LocalSendPayload); SpawnItself = new NetworkRequest <Action <string> >(LocalSpawnItself); SpawnItself.Invoke("Spawn new class"); }
public override void OnEnter() { base.OnEnter(); NetworkTransform mTransform = entity.GetState <IState> ().GetDynamic(propertyName.Value) as NetworkTransform; mTransform.SetTransforms(value.Value.transform); Finish(); }
/// <summary> /// Send local transform to the server /// </summary> /// <param name="ntransform"> /// A <see cref="NetworkTransform"/> /// </param> public void SendTransform(NetworkTransform ntransform) { Room room = sfs.LastJoinedRoom; ISFSObject data = new SFSObject(); ntransform.ToSFSObject(data); ExtensionRequest request = new ExtensionRequest("sendTransform", data, room, true); // True flag = UDP sfs.Send(request); }
void Start() { agent = GetComponent <NavMeshAgent>(); // Don’t update position automatically agent.updatePosition = false; networkTransform = GetComponent <NetworkTransform>(); }
private void HandleProjectileTransformReceived(ISFSObject data) { //Not my own projectiles if (data.GetInt("o") != SmartFoxConnection.Connection.MySelf.Id) { NetworkProjectileManager.Instance.MoveProjectile(data.GetInt("id"), NetworkTransform.fromSFSObject(data)); } }
public override void LoadServer(NetSceneDeltaState deltaScene) { float startOffset = 30; float ballSize = 18; var defaultPaddleSize = new Vector2(18, 70); Vector2 worldSize = Engine.Configuration.RenderSize; NetworkPlayer p1 = ServerGame?.Players[0]; NetworkPlayer p2 = ServerGame?.Players[1]; _pad1StartingPos = new Vector3(startOffset, worldSize.Y / 2 - defaultPaddleSize.Y / 2, 0); _pad1 = new PongPaddle("PaddleOne") { Position = _pad1StartingPos, Size = defaultPaddleSize, Owner = new NetworkPlayerHandle(p1?.Id), }; AddObject(_pad1); _pad2StartingPos = new Vector3(worldSize.X - startOffset - defaultPaddleSize.X, worldSize.Y / 2 - defaultPaddleSize.Y / 2, 0); _pad2 = new PongPaddle("PaddleTwo") { Position = _pad2StartingPos, Size = defaultPaddleSize, Owner = new NetworkPlayerHandle(p2?.Id), }; AddObject(_pad2); _ballStartingPos = new Vector3(worldSize.X / 2 - ballSize / 2, worldSize.Y / 2 - ballSize / 2, 0); var ball = new PongBall("Ball") { Position = _ballStartingPos, Size = new Vector2(ballSize) }; AddObject(ball); var upperWall = new NetworkTransform("UpperWall") { Position = new Vector3(-100, 0, 0), Size = new Vector2(worldSize.X + 200, 10) }; var lowerWall = new NetworkTransform("LowerWall") { Position = new Vector3(-100, worldSize.Y - 10, 0), Size = new Vector2(worldSize.X + 200, 10) }; AddObject(upperWall); AddObject(lowerWall); _betweenMatchTimer = new After(250); _betweenMatchTimer.End(); _collisionSystem = new PongCollisionProvider(this); base.LoadServer(deltaScene); }
// New item spawned message. Instantiating the item object. private void HandleItem(ISFSObject dt) { ISFSObject item = dt.GetSFSObject("item"); int id = item.GetInt("id"); string itemType = item.GetUtfString("type"); NetworkTransform ntransform = NetworkTransform.FromSFSObject(item); PlayerManager.Instance.SpawnItem(id, ntransform, itemType); }
public IEnumerator SetupComponent() { var gameObject = new GameObject(); m_networkTransform = gameObject.AddComponent <NetworkTransform>(); m_networkTransform.Entity.HasLocalAuthority = true; yield return(null); }
public override void OnStartClient() { if (m_VisualizerPrefab != null) { m_NetworkTransform = GetComponent <NetworkTransform>(); CreateLineMaterial(); m_Visualizer = (GameObject)Instantiate(m_VisualizerPrefab, transform.position, Quaternion.identity); } }
public void AddTransform(NetworkTransform networkTransform) { if (networkTransforms.Count >= maxNetworkTransforms) { networkTransforms.Dequeue(); } networkTransforms.Enqueue(networkTransform); }
public override void OnAwake() { ragdollSync = gameObject.AddComponent <NetworkTransform>(); NetworkIdentity c = gameObject.GetComponent <NetworkIdentity>(); gameObject.SetComponentIndex(c, 0xfffffff); // Ensure network writer is last OriginalMaterials = gameObject.GetComponent <RenderSkinnedComponent>().materials; }
public override void OnStartLocalPlayer() { base.OnStartLocalPlayer(); body = GetComponent<Rigidbody2D>(); anim = GetComponent<Animator>(); netTransform = GetComponent<NetworkTransform>(); groundCheck = transform.Find("groundCheck"); heroAudSrc = body.GetComponent<AudioSource>(); }
// Use this for initialization void Start() { sc = GameObject.Find("Synchronize Manager").GetComponent <StrategyController>(); strategy = sc.strategy; trans = this.gameObject.GetComponent <NetworkTransform>(); ResetStrategy(); }
// Creating NetworkTransform from Unity transform public static NetworkTransform FromTransform(Transform transform) { NetworkTransform trans = new NetworkTransform(); trans.position = transform.position; trans.angleRotation = transform.localEulerAngles; return(trans); }
void Update() { if (networkTransforms.Count > 0) { NetworkTransform networkTransform = networkTransforms.Dequeue(); gameObject.transform.localPosition = networkTransform.Position; gameObject.transform.localRotation = networkTransform.Rotation; } }
// Use this for initialization void Start() { player_rb = GetComponent <Rigidbody2D>(); nTrans = GetComponent <NetworkTransform>(); player_render = GetComponent <Renderer>(); last_position = player_rb.transform.position; spinning = false; }
void IHumanoidNetworking.DisableNetworkSync(GameObject obj) { NetworkTransform networkTransform = obj.GetComponent <NetworkTransform>(); if (networkTransform != null) { networkTransform.enabled = false; } }
void Start() { _netTransform = GetComponent<NetworkTransform>(); Rigidbody asteroidRB = GetComponent<Rigidbody>(); asteroidRB.AddForce(originalForce); asteroidRB.AddTorque(originalTorque); }
void Start() { _netTransform = GetComponent <NetworkTransform>(); Rigidbody asteroidRB = GetComponent <Rigidbody>(); asteroidRB.AddForce(originalForce); asteroidRB.AddTorque(originalTorque); }
private void Awake() { // Setting up references. m_GroundCheck = transform.Find("GroundCheck"); m_CeilingCheck = transform.Find("CeilingCheck"); m_Anim = GetComponent <Animator>(); m_Rigidbody2D = GetComponent <Rigidbody2D>(); _networkTransform = GetComponent <NetworkTransform>(); }
public static NetworkTransform fromTransform(Transform sendTransform) { NetworkTransform nTransform = new NetworkTransform(); nTransform.position = sendTransform.position; nTransform.rotation = sendTransform.rotation; return(nTransform); }
// calculate what position and velocity we should send to peers who do not own the characters public void CalculatePositionAndVelocityToSend(ref Vector2 position, ref Vector2 velocity, ref float distToDestination) { // to save some bandwidth we're sending 2d vectors. y is calculated procedurally based on the ground height at the point you are standing on so isn't needed to be sent position.x = transform.position.x; position.y = transform.position.z; Vector3 velocity3d = new Vector3(_rvoController.newVelocity.x, 0f, _rvoController.newVelocity.z); Vector3 positionToDestinationXZ = GameUtils.SubXZ(_locomotion.Destination, transform.position); distToDestination = Mathf.Max(positionToDestinationXZ.magnitude - _locomotion.ArrivalThreshold, 0f); // check if our current rvo controller velocity is gonna make us overshoot the target if (velocity3d.magnitude * GetNetworkUpdateInterval() > distToDestination) { // set our speed so we do not overshoot velocity3d = velocity3d.normalized * (distToDestination / GetNetworkUpdateInterval()); } const float DirectionTolerance = 0.819f; // 0.819f == cos(35 degrees) const float StoppingTime = 4f; // seconds // if the character is not heading towards the destination, or the destination is far away then it's not gonna stop soon and the distance can be unlimited if (GameUtils.DotXZ(velocity3d.normalized, positionToDestinationXZ.normalized) < DirectionTolerance || // character is not traveling towards target (probably RVO related) distToDestination > velocity3d.magnitude * GetNetworkUpdateInterval() * StoppingTime) // the destination is far away, so no stop is imminent { distToDestination = NetworkTransform.DistanceUnlimited; } // this section makes sure our velocity would not take us off the nav mesh Vector3 from = transform.position; Vector3 targetPosition = AStarPathfindingUtils.CalculateExitPoint(ref from, from + velocity3d, _locomotion.Simulator, true); // see if the target poition would cause us to exit the nav mesh float distToOriginalTargetSqr = GameUtils.GetDistSqXZ(from, from + velocity3d); float distToNewTargetSqr = GameUtils.GetDistSqXZ(from, targetPosition); if (distToNewTargetSqr < distToOriginalTargetSqr) // if the returned length is nearer, it means we hit an edge { const float NudgeIntoNavMeshDist = 0.1f; if (distToNewTargetSqr > NudgeIntoNavMeshDist * NudgeIntoNavMeshDist) { float distToNewTarget = Mathf.Sqrt(distToNewTargetSqr); // here we're moving targetPosition slightly back onto the nav mesh away from the nav mesh perimeter, this is to stop the character being moved slightly off mesh targetPosition = from + (((targetPosition - from) / distToNewTarget) * (distToNewTarget - NudgeIntoNavMeshDist)); } else { targetPosition = from; // edge is very close, so just use the from position as the target position } velocity3d = targetPosition - transform.position; } velocity.x = velocity3d.x; velocity.y = velocity3d.z; if (!NetworkTransform.IsMovement(new Vector3(velocity3d.x, 0f, velocity3d.z))) // is no movement being sent { // if we're sending a velocity of zero, we can have distance unlimited because there will be no movement anyway, so having distance unlimited means it can start moving quickly when a movement begins distToDestination = NetworkTransform.DistanceUnlimited; } }
public static NetworkTransform CreaOggettoNetworktransform(Vector3 posizione, Vector3 rotazione) { NetworkTransform trans = new NetworkTransform(); trans.position = posizione; trans.rotation = rotazione; trans.timeStamp = Time.time; return trans; }
public void ReceiveTransform(NetworkTransform nTransform) { if (interpolater != null) { interpolater.ReceivedTransform (nTransform); } else { //No interpolation - updating transform directly thisTransform.position = nTransform.Position; // Ignoring x and z rotation angles thisTransform.localEulerAngles = nTransform.AngleRotationFPS; } }
void SendTransform() { //if (lastState.IsDifferent(thisTransform, accuracy)) { if (timeLastSending >= sendingPeriod) { lastState = NetworkTransform.FromTransform(thisTransform); NetworkManager.Instance.SendTransform(lastState); timeLastSending = 0; return; } //} timeLastSending += Time.deltaTime; }
//MODIFICA BY LUCA /* private void InviaTransformLocali() { ISFSObject objOut = new SFSObject(); objOut.PutFloat("x", Statici.playerLocaleGO.transform.position.x); objOut.PutFloat("y", Statici.playerLocaleGO.transform.position.y); objOut.PutFloat("z", Statici.playerLocaleGO.transform.position.z); objOut.PutFloat("rot", Statici.playerLocaleGO.transform.rotation.eulerAngles.y); sfs.Send(new ExtensionRequest("regT", objOut, sfs.LastJoinedRoom)); controllerPlayer.MovementDirty = false; } */ public static void InviaTransformLocali(NetworkTransform ne) { ISFSObject objOut = new SFSObject(); objOut.PutFloat("x", ne.position.x); objOut.PutFloat("y", ne.position.y); objOut.PutFloat("z", ne.position.z); objOut.PutFloat("rx", ne.rotation.x); objOut.PutFloat("ry", ne.rotation.y); objOut.PutFloat("rz", ne.rotation.z); me.sfs.Send(new ExtensionRequest("regT", objOut, me.sfs.LastJoinedRoom)); // me.controllerPlayer.MovementDirty = false; }
//QUESTO METODO E' PER I PLAYER REMOTI public void ricevitransform(NetworkTransform net, int netUser) { if (playerLocale || user != netUser) return; if (inter == null) { transform.position = net.position; transform.rotation = Quaternion.Euler(net.rotation.x, net.rotation.y, net.rotation.z); } else { inter.ReceivedTransform(net); } }
//This method is called when receiving remote transform // We update lastState here to know last received transform state void ReceiveTransform(EsObject data) { Debug.Log("ReceiveTransform. receiveMode = " + receiveMode.ToString()); if (receiveMode) { Vector3 pos = NetworkTransform.getPlayerPosition(data); Quaternion rot = NetworkTransform.getPlayerRotation(data); lastState.InitFromValues(pos, rot); // Adding next received state to the queue NetworkTransform nextState = new NetworkTransform(this.gameObject); nextState.InitFromValues(pos, rot); queue.Enqueue(nextState); } }
public void SpawnPlayer(NetworkTransform ntransform, string name, int score) { Debug.Log ("SpawnPlayer"); if (Camera.main!=null) { //Destroy(Camera.main.gameObject); } // GameHUD.Instance.UpdateHealth(100); playerObj = GameObject.Instantiate(playerPrefab) as GameObject; playerObj.transform.position = ntransform.Position; playerObj.transform.localEulerAngles = ntransform.AngleRotationFPS; playerObj.SendMessage("StartSendTransform"); // PlayerScore.Instance.SetScore(name, score); }
public void SpawnRemotePlayer(int id, NetworkTransform ntransform, string name, int score) { GameObject playerObj = GameObject.Instantiate(enemyPrefab) as GameObject; playerObj.transform.position = ntransform.Position; playerObj.transform.localEulerAngles = ntransform.AngleRotationFPS; //AnimationSynchronizer animator = playerObj.GetComponent<AnimationSynchronizer>(); //animator.StartReceivingAnimation(); //PlayerScore.Instance.SetScore(name, score); RemotePlayer remotePlayer = playerObj.GetComponent<RemotePlayer>(); remotePlayer.Init(name); recipients[id] = playerObj.GetComponent<NetworkTransformReceiver>(); }
// This method is called in every Fixed Update in receiving mode. And it does transform interpolation to the latest state. void InterpolateTransform() { // If interpolationg if (interpolationPoint < maxInterpolationPoints) { interpolationPoint++; float t = interpolationPoint*interpolationDelta; if (t>1) t=1; transform.position = Vector3.Lerp(interpolateFrom.position, interpolateTo.position, t); transform.rotation = Quaternion.Slerp(interpolateFrom.rotation, interpolateTo.rotation, t); } else { // Finished interpolating to the next point if (interpolateTo!=null) { // Fixing interpolation result to set transform right to the next point transform.position = interpolateTo.position; transform.rotation = interpolateTo.rotation; } // Take new value from queue if (queue.Count!=0) { NetworkTransform nextTransform = queue.Dequeue() as NetworkTransform; //Start interpolation to the next transform // Set new final interpolation state and reset interpolationPoint interpolateTo = nextTransform; // Set new point from which to start interpolation as current transform interpolateFrom = new NetworkTransform(this.gameObject); interpolationPoint = 0; float frameRate = fpsStorage.GetCurrentFPS(); // Calculate the total number of interpolation points as number of frames during interpolationPriod maxInterpolationPoints = Convert.ToInt32(Math.Round(frameRate * interpolationPeriod)); // Reset interpolation deltaTime interpolationDelta = 1.0f / Convert.ToSingle(maxInterpolationPoints); } else { // If queue is empty just setting the transform to the last received state transform.position = lastState.position; transform.rotation = lastState.rotation; } } }
public void SpawnEnemy(int id, NetworkTransform ntransform, string name, int score, string avatar,string anim) { if (recipients.ContainsKey (id)) return; if (avatar.Equals("") || avatar.Equals(null)) avatar = "Jane-00"; string datos = avatar; string nameAvatar = datos.Substring(0,datos.IndexOf("-")); string textura = datos.Substring(datos.IndexOf("-")+1); // Debug.Log("id " + id); // Debug.Log("name avatar = "+ nameAvatar); // Debug.Log("textura = "+ textura); int currentAvatar = getAvatarInstance(nameAvatar); GameObject playerObj = GameObject.Instantiate(PlayersRemotes[currentAvatar]) as GameObject; ChangeAvatarTexture.Instance.changeTexture(playerObj, textura); Transform spawnTransform = GameObject.FindGameObjectWithTag("Respawn").transform; playerObj.transform.position = ntransform.Position;//spawnTransform.position; playerObj.transform.localEulerAngles = ntransform.AngleRotation;//spawnTransform.eulerAngles; AnimationSynchronizer animator = playerObj.GetComponent<AnimationSynchronizer>(); animator.setAnimation(anim,false); animator.StartReceivingAnimation(); PlayerScore.Instance.SetScore(name, score); PlayerInfo playerInfo = playerObj.GetComponent<PlayerInfo>(); playerInfo.Init(name); playerInfo.ShowInfo(); recipients[id] = playerObj.GetComponent<NetworkTransformReceiver>(); //controllers[id] = (CharacterController) playerObj.AddComponent("CharacterController"); playerObj.AddComponent<CharacterController>(); }
void Start() { Debug.Log ("sender start"); thisTransform = this.transform; lastState = NetworkTransform.FromTransform(thisTransform); }
// We call it on remote player to start receiving his transform void StartReceiving() { lastState = new NetworkTransform(this.gameObject); fpsStorage = GameObject.Find(" FPS").GetComponent(typeof(FPSStorage)) as FPSStorage; receiveMode = true; }
//This method is called when receiving remote transform // We update lastState here to know last received transform state void ReceiveTransform(SFSObject data) { if (receiveMode) { Vector3 pos = new Vector3(Convert.ToSingle(data.GetNumber("x")), Convert.ToSingle(data.GetNumber("y"))+yAdjust, Convert.ToSingle(data.GetNumber("z")) ); Quaternion rot = new Quaternion(Convert.ToSingle(data.GetNumber("rx")), Convert.ToSingle(data.GetNumber("ry")), Convert.ToSingle(data.GetNumber("rz")), Convert.ToSingle(data.GetNumber("w")) ); lastState.InitFromValues(pos, rot); // Adding next received state to the queue NetworkTransform nextState = new NetworkTransform(this.gameObject); nextState.InitFromValues(pos, rot); queue.Enqueue(nextState); } }
// Creating NetworkTransform from Unity transform public static NetworkTransform FromTransform(Transform transform) { NetworkTransform trans = new NetworkTransform(); trans.position = transform.position; trans.angleRotation = transform.localEulerAngles; return trans; }
public void SpawnItem(int id, NetworkTransform ntransform, string itemType) { GameObject itemPrefab = null; return; if (itemType == "Ammo") { itemPrefab = ammoPrefab; } else { itemPrefab = healthPrefab; } GameObject itemObj = GameObject.Instantiate(itemPrefab) as GameObject; itemObj.transform.position = ntransform.Position; itemObj.transform.localEulerAngles = ntransform.AngleRotationFPS; items[id] = itemObj; }
// Copies another NetworkTransform to itself public void Load(NetworkTransform ntransform) { this.position = ntransform.position; this.angleRotation = ntransform.angleRotation; this.timeStamp = ntransform.timeStamp; }
void Start() { instance=this; buffer = new SFSArray(); thisTransform = this.transform; lastState = NetworkTransform.FromTransform(thisTransform); }
public void SpawnPlayer(NetworkTransform ntransform, string name, int score, string avatar) { if (Camera.main!=null) { Destroy(Camera.main.gameObject); } if (avatar.Equals("") || avatar.Equals(null) || avatar.Equals("femenimo") || avatar.Equals("masculino")) avatar = "Jane-00"; //Debug.Log("avatar vacio"); string datos = avatar; string nameAvatar = datos.Substring(0,datos.IndexOf("-")); string textura = datos.Substring(datos.IndexOf("-")+1); // Debug.Log("name avatar = "+ nameAvatar); // Debug.Log("textura = "+ textura); int currentAvatar = getAvatarInstance(nameAvatar); /*GameObject*/ playerObj = GameObject.Instantiate(PlayersPrefabs[currentAvatar]) as GameObject; ChangeAvatarTexture.Instance.changeTexture(playerObj, textura); // smartFox=SmartFoxConnection.Connection; Vector3 pos=new Vector3(); float rot; if (!doorManager.firstTime){ string nextDoor= doorManager.doorBack; pos.x=(float)((Double)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(0)); pos.y=(float)((Double)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(1)); pos.z=(float)((Double)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(2)); int a=((int)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(3)); rot=(float)a; } else{ Transform spawnTransform = GameObject.FindGameObjectWithTag("Respawn").transform; doorManager.firstTime=false; pos=spawnTransform.position; rot=spawnTransform.rotation.y; } playerObj.transform.position = pos; playerObj.transform.Rotate(0,rot,0); playerObj.SendMessage("StartSendTransform"); ((PlayerSoundManager)playerObj.GetComponent("PlayerSoundManager")).PlaySpawn(); PlayerScore.Instance.SetScore(name, score); }
public void SpawnPlayer(NetworkTransform ntransform, string name, int score) { if (Camera.main!=null) { Destroy(Camera.main.gameObject); } playerName = name; playerObj = GameObject.Instantiate(playerPrefab) as GameObject; playerObj.transform.position = ntransform.Position; playerObj.transform.localEulerAngles = ntransform.AngleRotationFPS; playerObj.SendMessage("StartSendTransform"); }
//This method is called when receiving remote transform // We update lastState here to know last received transform state void ReceiveTransform(SFSObject data) { Debug.Log("ReceiveTransform()"); if (receiveMode) { Vector3 pos = new Vector3(Convert.ToSingle(data.GetNumber("x")), Convert.ToSingle(data.GetNumber("y")), Convert.ToSingle(data.GetNumber("z")) ); Quaternion rot = new Quaternion( Convert.ToSingle(0.0), Convert.ToSingle(data.GetNumber("ry")), Convert.ToSingle(0.0), Convert.ToSingle(data.GetNumber("w")) ); lastState.InitFromValues(pos, rot); // Adding next received state to the queue NetworkTransform nextState = new NetworkTransform(this.gameObject); nextState.InitFromValues(pos, rot); queue.Enqueue(nextState); Debug.Log("queue length: "+Convert.ToString(queue.Count)); } }
// Clone itself public static NetworkTransform Clone(NetworkTransform ntransform) { NetworkTransform trans = new NetworkTransform(); trans.Load(ntransform); return trans; }
void Start() { thisTransform = this.transform; lastState = NetworkTransform.FromTransform(thisTransform); }
void Start() { lastState = new NetworkTransform(this.gameObject); }