public int playerIndex = 0; // Player index of driver who spawned fake item box #endregion Fields #region Methods // Send data over network void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 position = Vector3.zero; Vector3 forwardVector = Vector3.zero; Vector3 upVector = Vector3.zero; if (stream.isWriting) { // Sending data... position = this.transform.position; forwardVector = this.transform.forward; upVector = this.transform.up; stream.Serialize(ref position); stream.Serialize(ref forwardVector); stream.Serialize(ref upVector); stream.Serialize(ref moveDirection); stream.Serialize(ref this.playerIndex); } else { // Receiving data... stream.Serialize(ref position); stream.Serialize(ref forwardVector); stream.Serialize(ref upVector); this.transform.position = position; this.transform.rotation = Quaternion.LookRotation(forwardVector, upVector); stream.Serialize(ref moveDirection); stream.Serialize(ref this.playerIndex); } }
//Rigidbody void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { var lIsKinematic = true; var lPosition = Vector3.zero; var lRot = Quaternion.identity; if (stream.isWriting) { lPosition = transform.position; lRot = transform.rotation; lIsKinematic = rigidbody.isKinematic; //lBoxPos = _supplyBox.transform.position; } stream.Serialize(ref lIsKinematic); stream.Serialize(ref lPosition); stream.Serialize(ref lRot); //stream.Serialize(ref lBoxPos); if (stream.isReading) { transform.position = lPosition; transform.rotation = lRot; rigidbody.isKinematic = lIsKinematic; } if(!lIsKinematic) { networkView.observed = rigidbody; Destroy(this); } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { float net_currentHealth = 0; float net_maxHealth = 0; bool net_isTargeted = false; if (stream.isWriting) { net_currentHealth = currentHealth; net_maxHealth = maxHealth; net_isTargeted = isTargeted; stream.Serialize(ref net_currentHealth); stream.Serialize(ref net_maxHealth); stream.Serialize(ref net_isTargeted); } else if (stream.isReading) { stream.Serialize(ref net_currentHealth); stream.Serialize(ref net_maxHealth); stream.Serialize(ref net_isTargeted); currentHealth = net_currentHealth; maxHealth = net_maxHealth; isTargeted = net_isTargeted; } }
private void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { if (stream.isWriting) { Debug.Log("Writing."); Vector3 pos = this.transform.position; Vector3 orientation = this.transform.eulerAngles; stream.Serialize(ref pos); stream.Serialize(ref orientation); } else { Debug.Log("Receiving."); Vector3 pos = Vector3.zero; Vector3 orientation = Vector3.zero; stream.Serialize(ref pos); stream.Serialize(ref orientation); this.transform.position = pos; this.transform.eulerAngles = orientation; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncPosition = Vector3.zero; Vector3 syncVelocity = Vector3.zero; if (stream.isWriting) { syncPosition = GetComponent<Rigidbody>().position; stream.Serialize(ref syncPosition); syncPosition = GetComponent<Rigidbody>().velocity; stream.Serialize(ref syncVelocity); //finPos = GetComponent<Rigidbody>().transform; //Debug.Log("FinPos: " + finPos); } else { stream.Serialize(ref syncPosition); stream.Serialize(ref syncVelocity); syncTime = 0f; syncDelay = Time.time - lastSynchronizationTime; lastSynchronizationTime = Time.time; syncEndPosition = syncPosition + syncVelocity * syncDelay; syncStartPosition = GetComponent<Rigidbody>().position; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { if (initialized) { Vector3 syncPosition = Vector3.zero; Quaternion syncRotation = Quaternion.identity; Vector3 syncVelocity = Vector3.zero; float syncHealth = 0f; if (stream.isWriting) { syncPosition = transform.position; syncRotation = transform.rotation; syncVelocity = rigidbody.velocity; syncHealth = playerDefense.health; } stream.Serialize(ref syncPosition); stream.Serialize(ref syncRotation); stream.Serialize(ref syncVelocity); stream.Serialize(ref syncHealth); if (stream.isReading) { syncTime = 0f; float currentTime = Time.time; syncDelay = currentTime - lastSynchronizationTime; lastSynchronizationTime = currentTime; startSyncPosition = transform.position; startSyncRotation = transform.rotation; endSyncPosition = syncPosition + syncVelocity * syncDelay; endSyncRotation = syncRotation; this.syncHealth = syncHealth; } } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 tempPos = Vector3.zero; Quaternion tempRot = Quaternion.identity; if((Network.isServer)&&(stream.isWriting)) { //Debug.Log("Hellow"); tempPos = transform.position; tempRot = transform.rotation; stream.Serialize(ref tempPos); stream.Serialize(ref tempRot); } else if(Network.isClient) { stream.Serialize(ref tempPos); stream.Serialize(ref tempRot); transform.position = tempPos; transform.rotation = tempRot; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncPosition = Vector3.zero; if ((networkView.isMine) && stream.isWriting) { //Write data to stream syncPosition = transform.position; stream.Serialize(ref syncPosition); print (gameObject.name); } else { //Get data from stream stream.Serialize(ref syncPosition); //Calculate sync delay (ping, kind of) syncDelay = Time.time - lastSynchronizationTime; lastSynchronizationTime = Time.time; NetworkManager.changeMenuDebugStatus("syncDelay: "+syncDelay); //Set new start and end position for movement interpolation syncStartPosition = syncEndPosition; syncEndPosition = syncPosition; print (syncStartPosition); print ("end: "+syncEndPosition); } }
void OnSerializeNetworkView (BitStream stream, NetworkMessageInfo info) { var pos = observedTransform.position; var rot = observedTransform.rotation; var target = unitController.target; var targetWaypoint = unitController.targetWaypoint; var health = unitController.health; if (stream.isWriting) { stream.Serialize(ref pos); stream.Serialize(ref rot); stream.Serialize(ref target); stream.Serialize(ref targetWaypoint); stream.Serialize(ref health); } else { stream.Serialize(ref pos); stream.Serialize(ref rot); stream.Serialize(ref target); stream.Serialize(ref targetWaypoint); stream.Serialize(ref health); unitController.serverPos = pos; unitController.serverRot = rot; unitController.target = target; unitController.targetWaypoint = targetWaypoint; unitController.health = health; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncPosition = Vector3.zero; Vector3 syncVelocity = Vector3.zero; if (stream.isWriting) { syncPosition = rigidbody.position; stream.Serialize(ref syncPosition); syncPosition = rigidbody.velocity; stream.Serialize(ref syncVelocity); } else { stream.Serialize(ref syncPosition); stream.Serialize(ref syncVelocity); syncTime = 0f; syncDelay = Time.time - lastSynchronizationTime; lastSynchronizationTime = Time.time; syncEndPosition = syncPosition + syncVelocity * syncDelay; syncStartPosition = rigidbody.position; } }
public virtual void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { if (_animator != null) { foreach (AnimatorControllerParameter param in _animator.parameters) { AnimatorControllerParameterType paramType = param.type; switch (paramType) { case AnimatorControllerParameterType.Bool: bool boolParam = _animator.GetBool (param.nameHash); stream.Serialize (ref boolParam); if (stream.isReading) { _animator.SetBool (param.nameHash, boolParam); } break; case AnimatorControllerParameterType.Float: float floatParam = _animator.GetFloat (param.nameHash); stream.Serialize (ref floatParam); if (stream.isReading) { _animator.SetFloat (param.nameHash, floatParam); } break; case AnimatorControllerParameterType.Int: int intParam = _animator.GetInteger (param.nameHash); stream.Serialize (ref intParam); if (stream.isReading) { _animator.SetInteger (param.nameHash, intParam); } break; } } } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { BoardLocation newLocation= new BoardLocation(new IntVector2(0,0), new IntVector2(0,0)); int maxSpeed = 0; IntVector2 direction = new IntVector2(0,0); BoardLocation lastBoardLocation = new BoardLocation(new IntVector2( 0, 0), new IntVector2(0,0)); if (stream.isWriting) { newLocation = this.boardLocation; maxSpeed = this.maxSpeed; direction = this.direction; lastBoardLocation = this.lastBoardLocation; newLocation.Serialize( stream ); stream.Serialize( ref maxSpeed ); direction.Serialize( stream ); lastBoardLocation.Serialize( stream ); } else { newLocation.DeSerialize( stream ); stream.Serialize( ref maxSpeed ); direction.DeSerialize( stream ); lastBoardLocation.DeSerialize( stream ); this.boardLocation = newLocation; this.maxSpeed = maxSpeed; this.direction = direction; this.lastBoardLocation = lastBoardLocation; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncPosition = Vector3.zero; Quaternion rot = Quaternion.identity; if (stream.isWriting) { syncPosition = transform.position; rot = transform.rotation; stream.Serialize(ref syncPosition); stream.Serialize(ref rot); } else { stream.Serialize(ref syncPosition); stream.Serialize(ref rot); syncTime = 0f; syncDelay = Time.time - lastSynchronizationTime; lastSynchronizationTime = Time.time; syncStartPosition = transform.position; syncEndPosition = syncPosition; qSrot = transform.rotation; qErot = rot; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { if (stream.isWriting) { // Vector3 pos = transform.position; Quaternion rot = transform.rotation; // int _animState = (int)animState; // stream.Serialize(ref pos); stream.Serialize(ref rot); // stream.Serialize(ref _animState); } else { // Vector3 revPos = Vector3.zero; Quaternion revRot = Quaternion.identity; // int _animState = 0; // stream.Serialize(ref revPos); stream.Serialize(ref revRot); // stream.Serialize(ref _animState); // currPos = revPos; currRot = revRot; // animState = (AnimState)_animState; } }
//Sends or Recieves Serialized variables over the network. void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { //Variable to be used over the network. Vector3 syncPosition = Vector3.zero; //If you're the owner of the object you are sending the objects position over the network. if(stream.isWriting) { //Set syncPosition to this objects current position. syncPosition = transform.position; //Send the position over the network. stream.Serialize(ref syncPosition); } //You're recieving the position from the Owner. else { //Serialize the new incoming position. stream.Serialize(ref syncPosition); syncTime = 0.0f; syncDelay = Time.time - lastSyncTime; lastSyncTime = Time.time; syncStartPosition = transform.position; syncEndPosition = syncPosition; } }
public void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 pos = observedTransform.position; Quaternion rot = observedTransform.rotation; if (stream.isWriting) { //Debug.Log("Server is writing"); stream.Serialize(ref pos); stream.Serialize(ref rot); } else { //This code takes care of the local client! stream.Serialize(ref pos); stream.Serialize(ref rot); receiver.serverPosition = pos; receiver.serverRotation = rot; //Smoothly correct clients position //receiver.lerpToTarget(); //Take care of data for interpolating remote objects movements // Shift up the buffer for ( int i = serverStateBuffer.Length - 1; i >= 1; i-- ) { serverStateBuffer[i] = serverStateBuffer[i-1]; } //Override the first element with the latest server info serverStateBuffer[0] = new NetworkState((float)info.timestamp, pos, rot); } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { //locateMarkersAndLimbs(); Vector3 tempPos = Vector3.zero; Quaternion tempRot = Quaternion.identity; //ADD THE parentP2 changes here as well! To stop jitter!! if((Network.isServer)&&(stream.isWriting)) { if(!parentP1) { tempPos = transform.position; tempRot = transform.rotation; stream.Serialize(ref tempPos); stream.Serialize(ref tempRot); } } if(Network.isClient) { if(!parentP1) { stream.Serialize(ref tempPos); stream.Serialize(ref tempRot); transform.position = tempPos; transform.rotation = tempRot; } } }
public void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 pos = observedTransform.position; Quaternion rot = observedTransform.rotation; if(stream.isWriting) { stream.Serialize(ref pos); stream.Serialize(ref rot); } else{ stream.Serialize(ref pos); stream.Serialize(ref rot); reciever.serverPos = pos; reciever.serverRot = rot; reciever.lerpToTarget(); for( int i = serverStateBuffer.Length - 1; i >= 1;i--){ serverStateBuffer[i] = serverStateBuffer[i-1]; } serverStateBuffer[0] = new NetState(); serverStateBuffer[0].setState((float)info.timestamp, pos, rot); } }
/* This function is automatically called every time it sends or receives datas. (To use for data that constantly changed) */ void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Quaternion syncRotation = Quaternion.identity; // The player is writing to the stream (= he moves its own Character...) if (stream.isWriting) { syncRotation = transform.localRotation; stream.Serialize(ref syncRotation); } // The ClientInstance of the player's opponent need to be moved else { stream.Serialize(ref syncRotation); // Interpolation : smoothing the transition from the old to the new data values syncTime = 0f; syncDelay = Time.time - lastSynchronizationTime; lastSynchronizationTime = Time.time; // Prediction : the rotation is "updated" before the new data is received syncStartRotation = transform.localRotation; syncEndRotation = syncRotation; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { if (stream.isWriting) { Vector3 pos = transform.localPosition; Quaternion rot = transform.localRotation; stream.Serialize(ref pos); stream.Serialize(ref rot); } else { Vector3 pos = Vector3.zero; Quaternion rot = Quaternion.identity; stream.Serialize(ref pos); stream.Serialize(ref rot); for (int i = m_BufferedState.Length - 1; i >= 1; i--) { m_BufferedState[i] = m_BufferedState[i - 1]; } State state; state.timestamp = info.timestamp; state.pos = pos; state.rot = rot; m_BufferedState[0] = state; m_TimestampCount = Mathf.Min(m_TimestampCount + 1, m_BufferedState.Length); for (int i = 0; i < m_TimestampCount - 1; i++) { if (m_BufferedState[i].timestamp < m_BufferedState[i + 1].timestamp) Debug.Log("State inconsistent"); } } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncPosition = Vector3.zero; Quaternion syncRotation = Quaternion.identity; Vector3 syncVelocity = Vector3.zero; if (stream.isWriting) { syncPosition = transform.position; stream.Serialize(ref syncPosition); syncRotation = transform.rotation; stream.Serialize(ref syncRotation); syncVelocity = controller.velocity; stream.Serialize(ref syncVelocity); } else { stream.Serialize(ref syncPosition); stream.Serialize(ref syncRotation); stream.Serialize(ref syncVelocity); syncTime = 0f; syncDelay = Time.time - lastSynchronizationTime; lastSynchronizationTime = Time.time; syncEndPosition = syncPosition + syncVelocity * syncDelay; syncStartPosition = transform.position; syncEndRotation = syncRotation; syncStartRotation = transform.rotation; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncDest = Vector3.zero; Vector3 syncPos = Vector3.zero; if (stream.isWriting && Network.isServer) { syncDest = destination; syncPos = this.gameObject.transform.position; stream.Serialize(ref syncDest); stream.Serialize(ref syncPos); } else if (stream.isReading) { stream.Serialize(ref syncDest); stream.Serialize(ref syncPos); destination = syncDest; if (agent != null) agent.SetDestination (destination); /* Vector3 diffPos = this.gameObject.transform.position - syncPos; if (diffPos.sqrMagnitude >= 1){ this.gameObject.transform.position = syncPos; } */ } }
// Update is called once per frame void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { { Vector3 position = rigidbody.position; Vector3 forward = transform.forward; Vector3 velocity = rigidbody.velocity; Vector3 angularVelocity = rigidbody.angularVelocity; if(stream.isWriting) { stream.Serialize(ref position); stream.Serialize(ref forward); stream.Serialize(ref velocity); stream.Serialize(ref angularVelocity); } else { stream.Serialize(ref position); targetPosition = position; stream.Serialize(ref forward); targetForward = forward; stream.Serialize(ref velocity); speed = velocity; stream.Serialize(ref angularVelocity); angularSpeed = angularVelocity; } } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { // Send data to server if (stream.isWriting) { Vector3 pos = transform.position; Quaternion rot = transform.rotation; bool swinging = false; // if(animator){ // AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0); // if(stateInfo.nameHash == slash1AnimationNameHash || stateInfo.nameHash == slash2AnimationNameHash){ // swinging = true; // } // } stream.Serialize(ref pos); stream.Serialize(ref rot); // stream.Serialize(ref swinging); } // Read data from remote client else { Vector3 pos = Vector3.zero; Quaternion rot = Quaternion.identity; bool hasSwing = false; stream.Serialize(ref pos); stream.Serialize(ref rot); // stream.Serialize(ref hasSwing); // 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 State state; state.timestamp = info.timestamp; state.pos = pos; state.rot = rot; // state.swinging = hasSwing; m_BufferedState[0] = state; // 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"); } } }
void OnSerializeNetworkView(BitStream stream) { p = rigidbody.position; r = rigidbody.rotation; m = 0; stream.Serialize(ref p); stream.Serialize(ref r); stream.Serialize(ref m); }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { // Send data to server if (stream.isWriting) { Vector3 pos = transform.position; Quaternion rot = transform.rotation; //Vector3 velocity = Vector3.zero; //rigidbody.velocity; //Vector3 angularVelocity = Vector3.zero; // rigidbody.angularVelocity; stream.Serialize(ref pos); //stream.Serialize(ref velocity); stream.Serialize(ref rot); //stream.Serialize(ref angularVelocity); } // Read data from remote client else { Vector3 pos = Vector3.zero; Vector3 velocity = Vector3.zero; Quaternion rot = Quaternion.identity; Vector3 angularVelocity = Vector3.zero; stream.Serialize(ref pos); //stream.Serialize(ref velocity); stream.Serialize(ref rot); //stream.Serialize(ref angularVelocity); // 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 State state; state.timestamp = info.timestamp; state.pos = pos; state.velocity = velocity; state.rot = rot; state.angularVelocity = angularVelocity; m_BufferedState[0] = state; // 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"); } } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info){ if(stream.isWriting){ int owner_id = owner_id_; stream.Serialize(ref owner_id); } else { int owner_id = -1; stream.Serialize(ref owner_id); owner_id_ = owner_id; } }
public static Vector3 Serialize (BitStream stream, Vector3 vector) // Serialize a Vector3 to a BitStream { float x = vector.x, y = vector.y, z = vector.z; stream.Serialize (ref x); stream.Serialize (ref y); stream.Serialize (ref z); return new Vector3 (x, y, z); }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { if (stream.isWriting) { float duration = remainingDuration; stream.Serialize (ref duration); } else { float duration = 0; stream.Serialize (ref duration); remainingDuration = duration; } }
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { float animTime = 0; if (stream.isWriting){ animTime = animation[animations[currentAnimation]].normalizedTime; stream.Serialize(ref animTime); } else { stream.Serialize(ref animTime); animation[animations[currentAnimation]].normalizedTime = animTime; } }
public override void SerializeNetwork(UnityEngine.BitStream stream) { float _attackingTimer = attackingTimer; if (stream.isWriting) { stream.Serialize(ref _attackingTimer); } else { stream.Serialize(ref _attackingTimer); attackingTimer = _attackingTimer; } }
public override void SerializeNetwork(UnityEngine.BitStream stream) { float _stunTime = StunTime; if (stream.isWriting) { stream.Serialize(ref _stunTime); } else { stream.Serialize(ref _stunTime); StunTime = _stunTime; } }