| public Serialize ( PhotonPlayer, &obj ) : void | ||
| obj | PhotonPlayer, | |
| return | void | |
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
int count = gameObject.transform.childCount;
bool available = isAvailable;
stream.Serialize(ref available);
stream.Serialize(ref count);
if (stream.isReading)
{
isAvailable = available;
if (!available)
{
GameObject.Find("CardHand" + PlayerPrefs.GetString("LoginUser", "Unknown")).GetComponent <HandPhoton>().isAvailable = true;
}
if (GameObject.Find("CardHand" + PlayerPrefs.GetString("LoginUser", "Unknown")).transform.childCount == 0 && count == 0)
{
GameObject.Find("Modal").transform.GetChild(0).gameObject.SetActive(true);
int mineScore = Int32.Parse(GameObject.Find("Score" + PlayerPrefs.GetString("LoginUser", "Unknown")).GetComponentInChildren <Text>().text);
int enemyScore = Int32.Parse(GameObject.Find("ScoreBox(Clone)").GetComponentInChildren <Text>().text);
if (mineScore > enemyScore)
{
GameObject.Find("FinalModal").GetComponentInChildren <Text>().text = "Безоговорочная победа!";
}
else
{
GameObject.Find("FinalModal").GetComponentInChildren <Text>().text = "Бесславное поражение!";
}
}
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Vector3 playerPos = character.transform.position;
Quaternion playerRot = character.transform.rotation;
Quaternion cameraRot = camera.transform.rotation;
stream.Serialize(ref playerPos);
stream.Serialize(ref playerRot);
stream.Serialize(ref cameraRot);
if (stream.isReading)
{
oldPosition = transform.position;
oldPlayerRot = transform.rotation;
newPosition = playerPos;
newPlayerRot = playerRot;
offsetTime = 0;
isSync = true;
oldCamerarRot = camera.transform.rotation;
newCameraRot = cameraRot;
// character.transform.position = playerPos;
// character.transform.rotation = playerRot;
// camera.transform.rotation = cameraRot;
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.SendNext(transform.position);
stream.SendNext(transform.rotation);
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);
correctHeadPos = pos;
correctHeadRot = rot;
onUpdateHeadPos = transform.localPosition;
onUpdateHeadRot = transform.localRotation;
fraction = 0;
}
}
// void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) {
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
Vector3 syncVelocity = Vector3.zero;
// Store current position.
syncPosition = gameObject.transform.position;
// If sending data
if (stream.isWriting)
{
// stream.Serialize allows for variable to be serialized and sent to other clients.
// Order of variables streamed should be the same when sending and receiving to avoid value mixups.
stream.Serialize(ref syncPosition);
}
// If receiving data
else
{
// stream.Serialize allows for variables to be serialized and received by clients.
stream.Serialize(ref syncPosition);
// Synchronization adjustment.
syncTime = 0f;
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
// Store start position for future calls.
syncStartPosition = syncPosition + syncVelocity * syncDelay;
// Store data locally
syncEndPosition = syncPosition;
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Debug.Log("merp");
if (stream.IsWriting)
{
Vector3 pos = GetPosition();
Quaternion rot = GetRotation();
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);
if (!photonView.IsMine)
{
//Debug.Log(string.Format("Received Position ({0})", pos.ToString()));
Sync(pos, rot);
}
else
{
Debug.Log("View is mine :(");
}
}
}
/// <summary>
/// While script is observed (in a PhotonView), this is called by PUN with a stream to write or read.
/// </summary>
/// <remarks>
/// The property stream.isWriting is true for the owner of a PhotonView. This is the only client that
/// should write into the stream. Others will receive the content written by the owner and can read it.
///
/// Note: Send only what you actually want to consume/use, too!
/// Note: If the owner doesn't write something into the stream, PUN won't send anything.
/// </remarks>
/// <param name="stream">Read or write stream to pass state of this GameObject (or whatever else).</param>
/// <param name="info">Some info about the sender of this stream, who is the owner of this PhotonView (and GameObject).</param>
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Debug.Log ("OnPhotonSerializeView");
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref playerId);
int _st = (int)stoneType;
stream.Serialize(ref _st);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
int _st = (int)stoneType;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref playerId);
stream.Serialize(ref _st);
latestCorrectPos = pos; // save this to move towards it in FixedUpdate()
onUpdatePos = transform.localPosition; // we interpolate from here to latestCorrectPos
fraction = 0; // reset the fraction we alreay moved. see Update()
transform.localRotation = rot; // this sample doesn't smooth rotation
stoneType = (StoneType)_st;
}
}
// this method is called by PUN when this script is being "observed" by a PhotonView (setup in inspector)
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
// Always send transform (depending on reliability of the network view)
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
// When receiving, buffer the information
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
lastMovement = (pos - latestCorrectPos) / (Time.time - lastTime);
lastTime = Time.time;
latestCorrectPos = pos;
transform.position = latestCorrectPos;
}
}
// this method is called by PUN when this script is being "observed" by a PhotonView (setup in inspector)
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
// Always send transform (depending on reliability of the network view)
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
// When receiving, buffer the information
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
lastMovement = (pos - latestCorrectPos) / (Time.time - lastTime);
lastTime = Time.time;
latestCorrectPos = pos;
transform.position = latestCorrectPos;
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
int pid = 0;
string path = null;
if (stream.isWriting)
{
NetworkReference nref = NetworkReference.FromTransform(transform.parent);
pid = nref.parentHandleId;
path = nref.pathFromParent;
// Send update
stream.Serialize(ref pid);
stream.Serialize(ref path);
}
else
{
// Receive updated state information
stream.Serialize(ref pid);
stream.Serialize(ref path);
newState.timestamp = info.timestamp;
newState.parentId = pid;
newState.path = path;
}
}
// this method is called by PUN when this script is being "observed" by a PhotonView (setup in inspector)
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
// the controlling player of a cube sends only the position
Vector3 pos = transform.localPosition;
stream.Serialize(ref pos);
}
else
{
// other players (not controlling this cube) will read the position and timing and calculate everything else based on this
Vector3 updatedLocalPos = Vector3.zero;
stream.Serialize(ref updatedLocalPos);
double timeDiffOfUpdates = info.timestamp - this.lastTime; // the time that passed after the sender sent it's previous update
this.lastTime = info.timestamp;
// the movementVector calculates how far the "original" cube moved since it sent the last update.
// we calculate this based on the sender's timing, so we exclude network lag. that makes our movement smoother.
this.movementVector = (updatedLocalPos - this.latestCorrectPos) / (float)timeDiffOfUpdates;
// the errorVector is how far our cube is away from the incoming position update. using this corrects errors somewhat, until the next update arrives.
// with this, we don't have to correct our cube's position with a new update (which introduces visible, hard stuttering).
this.errorVector = (updatedLocalPos - transform.localPosition) / (float)timeDiffOfUpdates;
// next time we get an update, we need this update's position:
this.latestCorrectPos = updatedLocalPos;
}
}
// Token: 0x0600024E RID: 590 RVA: 0x0000F84C File Offset: 0x0000DA4C
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 localPosition = base.transform.localPosition;
Quaternion localRotation = base.transform.localRotation;
stream.Serialize(ref localPosition);
stream.Serialize(ref localRotation);
stream.SendNext(Environment.TickCount);
return;
}
Vector3 zero = Vector3.zero;
Quaternion identity = Quaternion.identity;
stream.Serialize(ref zero);
stream.Serialize(ref identity);
for (int i = this.m_BufferedState.Length - 1; i >= 1; i--)
{
this.m_BufferedState[i] = this.m_BufferedState[i - 1];
}
CubeInter.State state;
state.timestamp = info.timestamp;
state.pos = zero;
state.rot = identity;
this.m_BufferedState[0] = state;
this.m_TimestampCount = Mathf.Min(this.m_TimestampCount + 1, this.m_BufferedState.Length);
for (int j = 0; j < this.m_TimestampCount - 1; j++)
{
if (this.m_BufferedState[j].timestamp < this.m_BufferedState[j + 1].timestamp)
{
Debug.Log("State inconsistent");
}
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
// наша позиция и поворот
Vector3 position = transform.position;
Quaternion rotation = transform.rotation;
// сериализуем/передаём в поток нашу позицию
stream.Serialize(ref position);
stream.Serialize(ref rotation);
// если сейчас вызван метод с потоком на чтение
if (stream.isReading)
{
//transform.position = position;
oldPos = transform.position;
newPos = position;
offsetTime = 0f; // обновили позицию и сбрасываем время
isSynch = true;
//transform.rotation = rotation;
old_rotation = transform.rotation;
new_rotation = rotation;
offsetTime_rotation = 0f;
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
this.latestCorrectPos = pos; // save this to move towards it in FixedUpdate()
this.onUpdatePos = transform.localPosition; // we interpolate from here to latestCorrectPos
this.fraction = 0; // reset the fraction we alreay moved. see Update()
transform.localRotation = rot; // this sample doesn't smooth rotation
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo 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);
latestCorrectPos = pos;
onUpdatePos = transform.localPosition;
fraction = 0;
transform.localRotation = rot;
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
this.latestCorrectPos = pos; // save this to move towards it in FixedUpdate()
this.onUpdatePos = transform.localPosition; // we interpolate from here to latestCorrectPos
this.fraction = 0; // reset the fraction we alreay moved. see Update()
transform.localRotation = rot; // this sample doesn't smooth rotation
}
}
/// <summary>
/// Serialization method. Used to sync properties every frame.
/// </summary>
/// <param name="stream"></param>
/// <param name="info"></param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (myBullet == null)
{
return;
}
Vector3 positionAndRotation = Vector3.zero;
if (stream.isWriting)
{
positionAndRotation.x = myBullet.transform.position.x;
positionAndRotation.y = myBullet.transform.eulerAngles.y;
positionAndRotation.z = myBullet.transform.position.z;
stream.Serialize(ref positionAndRotation);
}
else
{
stream.Serialize(ref positionAndRotation);
Vector3 receivedPosition = new Vector3(positionAndRotation.x, this.transform.position.y, positionAndRotation.z);
Quaternion receivedRotation = Quaternion.Euler(this.transform.eulerAngles.x, positionAndRotation.y, this.transform.eulerAngles.z);
myBullet.OnNetworkUpdate(receivedPosition, receivedRotation);
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Debug.Log("serializing " + this.name + " " + stream.IsWriting);
stream.Serialize(ref networkPosition);
stream.Serialize(ref networkRotation);
stream.Serialize(ref health);
}
// this method is called by PUN when this script is being "observed" by a PhotonView (setup in inspector)
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
// the controlling player of a cube sends only the position
Vector3 pos = transform.localPosition;
stream.Serialize(ref pos);
}
else
{
// other players (not controlling this cube) will read the position and timing and calculate everything else based on this
Vector3 updatedLocalPos = Vector3.zero;
stream.Serialize(ref updatedLocalPos);
double timeDiffOfUpdates = info.timestamp - this.lastTime; // the time that passed after the sender sent it's previous update
this.lastTime = info.timestamp;
// the movementVector calculates how far the "original" cube moved since it sent the last update.
// we calculate this based on the sender's timing, so we exclude network lag. that makes our movement smoother.
this.movementVector = (updatedLocalPos - this.latestCorrectPos) / (float)timeDiffOfUpdates;
// the errorVector is how far our cube is away from the incoming position update. using this corrects errors somewhat, until the next update arrives.
// with this, we don't have to correct our cube's position with a new update (which introduces visible, hard stuttering).
this.errorVector = (updatedLocalPos - transform.localPosition) / (float)timeDiffOfUpdates;
// next time we get an update, we need this update's position:
this.latestCorrectPos = updatedLocalPos;
}
}
public override void Serialize(PhotonStream stream, PhotonMessageInfo info)
{
stream.Serialize(ref parentNetRef.parentHandleId);
stream.Serialize(ref parentNetRef.pathFromParent);
//if (HasChanged() || stream.isReading) {
// Debug.Log("PARENT " + (stream.isWriting ? "Sent " : "Recvd ") + this + " --> " + parentNetRef);
//}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
//Получение данных о позиции и повороте текущего персонажа и отправка этих данных другим пользователям
networkPos = transform.position;
networkRot = bottom.transform.rotation;
stream.Serialize(ref networkPos);
stream.Serialize(ref networkRot);
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
stream.Serialize(ref networkPosition);
stream.Serialize(ref networkRotation);
stream.Serialize(ref networkVelocity);
stream.Serialize(ref networkAngularVelocity);
stream.Serialize(ref networkUseGravity);
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo 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");
}
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
if(anim != null)
{
float zVel = anim.GetFloat("Z_Vel");
float xVel = anim.GetFloat("X_Vel");
bool jumping = anim.GetBool("Jumping");
stream.Serialize(ref zVel);
stream.Serialize(ref xVel);
stream.Serialize(ref jumping);
}
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
if(anim != null)
{
float zVel = 0;
float xVel = 0;
bool jumping = false;
stream.Serialize(ref zVel);
stream.Serialize(ref xVel);
stream.Serialize(ref jumping);
anim.SetFloat("Z_Vel",zVel);
anim.SetFloat("X_Vel",xVel);
anim.SetBool("Jumping",jumping);
}
latestCorrectPos = pos; // save this to move towards it in Update()
onUpdatePos = transform.localPosition; // we interpolate from here to latestCorrectPos
latestCorrectRot = rot; // same with rotation
onUpdateRot = transform.localRotation;
fraction = 0; // reset the fraction we alreay moved. see Update()
if(firstUpdate)
{
transform.localPosition = pos;
transform.localRotation = rot;
firstUpdate = false;
}
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.IsWriting)
{
stream.Serialize(ref health);
}
else
{
stream.Serialize(ref health);
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.IsWriting)
{
stream.Serialize(ref currentHoldTime);
}
else
{
stream.Serialize(ref currentHoldTime);
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
stream.Serialize(ref position);
stream.Serialize(ref prevPosition);
stream.Serialize(ref orientation);
stream.Serialize(ref prevOrientation);
if (!stream.isWriting)
{
sendTime = info.timestamp;
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
stream.Serialize(ref Kappa);
}
else
{
stream.Serialize(ref Kappa);
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
stream.Serialize(ref text);
}
else
{
text = "";
stream.Serialize(ref text); // pos被填充。必须在某个地方使用
}
}
private void OnPhotonSerializeView(PhotonStream Stream, PhotonMessageInfo Info)
{
// Send data to server
if (Stream.isWriting)
{
// Not sending data when in slow-motion or fast-motion.
if (Time.timeScale != NormalTimeScale)
return;
var Position = rigidbody.position;
var Rotation = rigidbody.rotation;
var Velocity = rigidbody.velocity;
var AngularVelocity = rigidbody.angularVelocity;
Stream.Serialize(ref Position);
Stream.Serialize(ref Velocity);
Stream.Serialize(ref Rotation);
Stream.Serialize(ref AngularVelocity);
}
// Read data from remote client
else
{
var Position = Vector3.zero;
var Velocity = Vector3.zero;
var Rotation = Quaternion.identity;
var AngularVelocity = Vector3.zero;
Stream.Serialize(ref Position);
Stream.Serialize(ref Velocity);
Stream.Serialize(ref Rotation);
Stream.Serialize(ref AngularVelocity);
// Shift the buffer sideways, deleting the last state.
for (var i = BufferedStates.Length - 1; i >= 1; i--)
BufferedStates[i] = BufferedStates[i - 1];
// Record current state in slot 0
BufferedStates[0] = new RigidBodyState(Info.timestamp, Position, Velocity, Rotation, AngularVelocity);
// 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.
UsedBufferedStatesCount = Mathf.Min(UsedBufferedStatesCount + 1, BufferedStates.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 (var i = 0; i < UsedBufferedStatesCount - 1; i++)
{
if (BufferedStates[i].Timestamp < BufferedStates[i + 1].Timestamp)
Debug.Log("State inconsistent");
}
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Vector3 pos = transform.position;
stream.Serialize(ref pos);
transform.position = pos;
Quaternion rot = transform.rotation;
stream.Serialize(ref rot);
transform.rotation = rot;
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
Vector3 pos = transform.position;
Quaternion rot = transform.rotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
if (stream.isReading)
{
transform.position = pos;
transform.rotation = rot;
}
}
void OnPhotonSerializeViev(PhotonStream stream, PhotonMessageInfo info)
{
Vector3 pos = transform.position;
Quaternion rot = transform.rotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
if (stream.isReading)
{
transform.position = pos;
transform.rotation = rot;
}
}
// in an "observed" script:
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = this.transform.localPosition;
stream.Serialize(ref pos);
}
else
{
Vector3 pos = Vector3.zero;
stream.Serialize(ref pos); // pos gets filled-in. must be used somewhere
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
stream.Serialize(ref pos);
}
else
{
Vector3 pos = Vector3.zero;
stream.Serialize(ref pos); // pos gets filled-in. must be used somewhere
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
stream.Serialize(ref pos);
}
else
{
Vector3 pos = Vector3.zero;
stream.Serialize(ref pos);
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.IsWriting)
{
stream.Serialize(ref _pressCount);
minigame.UpdateTugOfWar();
}
else
{
stream.Serialize(ref _pressCount);
minigame.UpdateTugOfWar();
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
// Always send transform (depending on reliability of the network view)
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.SendNext(Environment.TickCount);
}
// When receiving, buffer the information
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
int localTimeOfSend = (int)stream.ReceiveNext();
//Debug.Log("timeDiff" + (Environment.TickCount - localTimeOfSend) + " update age: " + (PhotonNetwork.time - info.timestamp));
// Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1
for (int i = this.m_BufferedState.Length - 1; i >= 1; i--)
{
this.m_BufferedState[i] = this.m_BufferedState[i - 1];
}
// Save currect received state as 0 in the buffer, safe to overwrite after shifting
State state;
state.timestamp = info.timestamp;
state.pos = pos;
state.rot = rot;
this.m_BufferedState[0] = state;
// Increment state count but never exceed buffer size
this.m_TimestampCount = Mathf.Min(this.m_TimestampCount + 1, this.m_BufferedState.Length);
// Check integrity, lowest numbered state in the buffer is newest and so on
for (int i = 0; i < this.m_TimestampCount - 1; i++)
{
if (this.m_BufferedState[i].timestamp < this.m_BufferedState[i + 1].timestamp)
{
Debug.Log("State inconsistent");
}
}
}
}
// used as Observed component in a PhotonView, this only reads/writes the position
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.IsWriting)
{
int data = players;
stream.Serialize(ref data);
}
else
{
int data = 0;
stream.Serialize(ref data); // pos gets filled-in. must be used somewhere
players = data;
}
}
/**
* Serialises state changes for client.
* Currently, the whole state is sent, even if only part of the state changed.
*/
protected virtual void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (DetectChange() && stream.isWriting)
{
Vector2 pos = transform.position;
float rotation = transform.rotation.eulerAngles.z;
stream.Serialize(ref pos);
stream.Serialize(ref rotation);
}
else if (!stream.isWriting)
{
Debug.LogWarning("Server object is receiving positional info from client");
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
bool curActive = this.gameObject.GetActive();
if (stream.isWriting)
{
if (HasChanged())
{
stream.Serialize(ref curActive);
stream.Serialize(ref grabOwner);
stream.Serialize(ref grabParent);
stream.Serialize(ref grabAttachPath);
}
}
else
{
stream.Serialize(ref curActive);
stream.Serialize(ref grabOwner);
stream.Serialize(ref grabParent);
stream.Serialize(ref grabAttachPath);
this.gameObject.SetActive(curActive);
if (oldGrabParent != grabParent || oldGrabAttachPath != grabAttachPath)
{
PerformGrab();
}
}
MemorizeState();
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
// Always send transform (depending on reliability of the network view)
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.SendNext(Environment.TickCount);
}
// When receiving, buffer the information
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
//int localTimeOfSend = (int)stream.ReceiveNext();
//Debug.Log("timeDiff" + (Environment.TickCount - localTimeOfSend) + " update age: " + (PhotonNetwork.time - info.timestamp));
// Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1
for (int i = this.m_BufferedState.Length - 1; i >= 1; i--)
{
this.m_BufferedState[i] = this.m_BufferedState[i - 1];
}
// Save currect received state as 0 in the buffer, safe to overwrite after shifting
State state;
state.timestamp = info.timestamp;
state.pos = pos;
state.rot = rot;
this.m_BufferedState[0] = state;
// Increment state count but never exceed buffer size
this.m_TimestampCount = Mathf.Min(this.m_TimestampCount + 1, this.m_BufferedState.Length);
// Check integrity, lowest numbered state in the buffer is newest and so on
for (int i = 0; i < this.m_TimestampCount - 1; i++)
{
if (this.m_BufferedState[i].timestamp < this.m_BufferedState[i + 1].timestamp)
{
Debug.Log("State inconsistent");
}
}
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
string score = gameObject.GetComponentInChildren <Text>().text;
Vector3 pos = transform.position;
stream.Serialize(ref pos);
stream.Serialize(ref score);
if (stream.isReading)
{
pos.y = -pos.y;
transform.position = pos;
transform.parent = GameObject.Find("NumberCanvas").transform;
gameObject.GetComponentInChildren <Text>().text = score;
}
}
// used as Observed component in a PhotonView, this only reads/writes the position
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.IsWriting)
{
Vector3 pos = transform.localPosition;
stream.Serialize(ref pos);
stream.SendNext(Health);
}
else
{
Vector3 pos = Vector3.zero;
stream.Serialize(ref pos); // pos gets filled-in. must be used somewhere
Health = (float)stream.ReceiveNext();
}
}
/// <summary>
/// While script is observed (in a PhotonView), this is called by PUN with a stream to write or read.
/// </summary>
/// <remarks>
/// The property stream.isWriting is true for the owner of a PhotonView. This is the only client that
/// should write into the stream. Others will receive the content written by the owner and can read it.
///
/// Note: Send only what you actually want to consume/use, too!
/// Note: If the owner doesn't write something into the stream, PUN won't send anything.
/// </remarks>
/// <param name="stream">Read or write stream to pass state of this GameObject (or whatever else).</param>
/// <param name="info">Some info about the sender of this stream, who is the owner of this PhotonView (and GameObject).</param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.rotation;
int hlth = health;
//ItemType itmType = itemType;
float rspwnTime = respawnTime;
float rspwnStrt = respawnStart;
int st = (int)state;
float dsbleTime = disableTime;
int tm = (int)team;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref hlth);
stream.Serialize(ref rspwnTime);
stream.Serialize(ref rspwnStrt);
stream.Serialize(ref st);
stream.Serialize(ref dsbleTime);
stream.Serialize(ref tm);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
int hlth = 0;
float rspwnTime = 0;
float rspwnStrt = 0;
int st = 0;
float dsbleTime = 0;
int tm = 0;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref hlth);
stream.Serialize(ref rspwnTime);
stream.Serialize(ref rspwnStrt);
stream.Serialize(ref st);
stream.Serialize(ref dsbleTime);
stream.Serialize(ref tm);
transform.position = pos;
transform.rotation = rot; // this sample doesn't smooth rotation
health = hlth;
respawnTime = rspwnTime;
respawnStart = rspwnStrt;
state = (ItemState)st;
disableTime = dsbleTime;
team = (Team)tm;
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
networkCulling.SetGroup(photonView);
Vector3 pos = transform.position;
Quaternion rot = transform.rotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
else
{
Vector3 pos = transform.position;
Quaternion rot = transform.rotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
SetPositionRotation(pos,rot); //Your own synchronization code (or just directly set the position/rotation for now)
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
int _val = pointValue;
Vector3 _pos = transform.position;
Vector3 _scl = transform.localScale;
stream.Serialize(ref _val);
stream.Serialize(ref _pos);
stream.Serialize(ref _scl);
}
else
{
int _val = 0;
Vector3 _pos = Vector3.zero;
Vector3 _scl = Vector3.one;
stream.Serialize(ref _val);
stream.Serialize(ref _pos);
stream.Serialize(ref _scl);
pointValue = _val;
transform.position = _pos;
transform.localScale = _scl;
}
}
/// <summary>
/// Serialization method. Used to sync properties every frame.
/// </summary>
/// <param name="stream"></param>
/// <param name="info"></param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (myBullet == null) return;
Vector3 positionAndRotation = Vector3.zero;
if (stream.isWriting)
{
positionAndRotation.x = myBullet.transform.position.x;
positionAndRotation.y = myBullet.transform.eulerAngles.y;
positionAndRotation.z = myBullet.transform.position.z;
stream.Serialize(ref positionAndRotation);
}
else
{
stream.Serialize(ref positionAndRotation);
Vector3 receivedPosition = new Vector3(positionAndRotation.x, this.transform.position.y, positionAndRotation.z);
Quaternion receivedRotation = Quaternion.Euler(this.transform.eulerAngles.x, positionAndRotation.y, this.transform.eulerAngles.z);
myBullet.OnNetworkUpdate(receivedPosition, receivedRotation);
}
}
/// <summary>
/// While script is observed (in a PhotonView), this is called by PUN with a stream to write or read.
/// </summary>
/// <remarks>
/// The property stream.isWriting is true for the owner of a PhotonView. This is the only client that
/// should write into the stream. Others will receive the content written by the owner and can read it.
///
/// Note: Send only what you actually want to consume/use, too!
/// Note: If the owner doesn't write something into the stream, PUN won't send anything.
/// </remarks>
/// <param name="stream">Read or write stream to pass state of this GameObject (or whatever else).</param>
/// <param name="info">Some info about the sender of this stream, who is the owner of this PhotonView (and GameObject).</param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
//timeout_timer = TIMEOUT_MAX;
if (stream.isWriting)
{
Vector3 pos = transform.position;
Quaternion rot = transform.rotation;
Vector3 scale = transform.localScale;
if(debug)
{
print("sending pos: " + pos.ToString() + " rot: " + rot.ToString() + " scale: " + scale.ToString() + "rand: " + Random.Range(0.1f, 100.0f));
}
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref scale);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
Vector3 scale = Vector3.zero;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref scale);
if(debug)
{
print("receiving pos: " + pos.ToString() + " rot: " + rot.ToString() + " scale: " + scale.ToString() + "rand: " + Random.Range(0.1f, 100.0f));
}
latestCorrectPos = pos; // save this to move towards it in FixedUpdate()
latestCorrectRot = rot;
latestCorrectScale = scale;
onUpdatePos = transform.position; // we interpolate from here to latestCorrectPos
onUpdateRot = transform.rotation;
onUpdateScale = transform.localScale;
fraction = 0; // reset the fraction we alreay moved. see Update()
}
}
/// <summary>
/// Serialization method. Used to sync properties every frame.
/// </summary>
/// <param name="stream"></param>
/// <param name="info"></param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (myPlayer == null) return;
Vector3 positionAndRotation = Vector3.zero;
int actualStateCode = 0;
Vector2 velocity = Vector3.zero;
if (stream.isWriting)
{
positionAndRotation.x = myPlayer.transform.position.x;
positionAndRotation.y = myPlayer.childTransform.eulerAngles.y;
positionAndRotation.z = myPlayer.transform.position.z;
stream.Serialize(ref positionAndRotation);
actualStateCode = myPlayer.actualState.GetHashCode();
velocity = new Vector2(myPlayer.GetComponent<Rigidbody>().velocity.x, myPlayer.GetComponent<Rigidbody>().velocity.z);
stream.Serialize(ref velocity);
stream.Serialize(ref actualStateCode);
}
else
{
stream.Serialize(ref positionAndRotation);
Vector3 receivedPosition = new Vector3(positionAndRotation.x,this.transform.position.y,positionAndRotation.z);
Quaternion receivedRotation = Quaternion.Euler(this.transform.eulerAngles.x,positionAndRotation.y,this.transform.eulerAngles.z);
myPlayer.transform.position = receivedPosition;
myPlayer.childTransform.rotation = receivedRotation;
stream.Serialize(ref velocity);
myPlayer.OnNetworkUpdate(receivedPosition, receivedRotation,velocity);
stream.Serialize(ref actualStateCode);
myPlayer.ChangeState((PlayerStates)actualStateCode);
}
}
/// <summary>
/// While script is observed (in a PhotonView), this is called by PUN with a stream to write or read.
/// </summary>
/// <remarks>
/// The property stream.isWriting is true for the owner of a PhotonView. This is the only client that
/// should write into the stream. Others will receive the content written by the owner and can read it.
///
/// Note: Send only what you actually want to consume/use, too!
/// Note: If the owner doesn't write something into the stream, PUN won't send anything.
/// </remarks>
/// <param name="stream">Read or write stream to pass state of this GameObject (or whatever else).</param>
/// <param name="info">Some info about the sender of this stream, who is the owner of this PhotonView (and GameObject).</param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = upperBody.transform.rotation;
int kt = currentPoints;
int kc = killCount;
int dc = deathCount;
int ttg = totalPointsGained;
int ttl = totalPointsLost;
int ttb = totalPointsBanked;
int hlth = health;
int mxhlth = stats.health;
bool wtngFrRspwn = waitingForRespawn;
int tm = (int)team;
float invltime = invulnerabilityTime;
int[] amms = new int[guns.Length];
for (int i = 0; i < guns.Length; i++)
{
amms[i] = guns[i].ammo;
}
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref kt);
stream.Serialize(ref kc);
stream.Serialize(ref dc);
stream.Serialize(ref ttg);
stream.Serialize(ref ttl);
stream.Serialize(ref ttb);
stream.Serialize(ref hlth);
stream.Serialize(ref mxhlth);
stream.Serialize(ref wtngFrRspwn);
stream.Serialize(ref tm);
stream.Serialize(ref invltime);
for (int j = 0; j < amms.Length; j++)
{
stream.Serialize(ref amms[j]);
}
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
int kt = 0;
int kc = 0;
int dc = 0;
int ttg = 0;
int ttl = 0;
int ttb = 0;
int hlth = 0;
int mxhlth = 0;
bool wtngFrRspwn = false;
int tm = 0;
float invltime = 0.0f;
int[] amms = new int[guns.Length];
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref kt);
stream.Serialize(ref kc);
stream.Serialize(ref dc);
stream.Serialize(ref ttg);
stream.Serialize(ref ttl);
stream.Serialize(ref ttb);
stream.Serialize(ref hlth);
stream.Serialize(ref mxhlth);
stream.Serialize(ref wtngFrRspwn);
stream.Serialize(ref tm);
stream.Serialize(ref invltime);
for (int i = 0; i < amms.Length; i++)
{
stream.Serialize(ref amms[i]);
}
latestCorrectPos = pos; // save this to move towards it in FixedUpdate()
onUpdatePos = transform.localPosition; // we interpolate from here to latestCorrectPos
fraction = 0; // reset the fraction we alreay moved. see Update()
upperBody.transform.rotation = rot; // this sample doesn't smooth rotation
currentPoints = kt;
killCount = kc;
deathCount = dc;
totalPointsGained = ttg;
totalPointsLost = ttl;
totalPointsBanked = ttb;
health = hlth;
waitingForRespawn = wtngFrRspwn;
team = (Team)tm;
invulnerabilityTime = invltime;
for (int j = 0; j < amms.Length; j++)
{
guns[j].ammo = amms[j];
}
}
}
/// <summary>
/// While script is observed (in a PhotonView), this is called by PUN with a stream to write or read.
/// </summary>
/// <remarks>
/// The property stream.isWriting is true for the owner of a PhotonView. This is the only client that
/// should write into the stream. Others will receive the content written by the owner and can read it.
///
/// Note: Send only what you actually want to consume/use, too!
/// Note: If the owner doesn't write something into the stream, PUN won't send anything.
/// </remarks>
/// <param name="stream">Read or write stream to pass state of this GameObject (or whatever else).</param>
/// <param name="info">Some info about the sender of this stream, who is the owner of this PhotonView (and GameObject).</param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
float speed = anim.GetFloat("Speed");
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref speed);
stream.Serialize(ref facingRight);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
float speed = 0;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref speed);
stream.Serialize(ref facingRight);
mLatestCorrectPos = pos; // save this to move towards it in FixedUpdate()
mOnUpdatePos = transform.localPosition; // we interpolate from here to latestCorrectPos
mFraction = 0; // reset the fraction we alreay moved. see Update()
transform.localRotation = rot; // this sample doesn't smooth rotation
anim.SetFloat("Speed", speed);
SetFacingDirection(facingRight);
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 position = transform.localPosition;
Vector3 velocity = GetComponent<Rigidbody>().velocity;
Vector3 acceleration = GetComponent<ControllerManager>().getAcceleration();
Quaternion rotation = transform.localRotation;
Vector3 angularVelocity = GetComponent<Rigidbody>().angularVelocity;
float power = GetComponent<PropellersController>().getPower();
stream.Serialize(ref position);
stream.Serialize(ref velocity);
stream.Serialize(ref acceleration);
stream.Serialize(ref rotation);
stream.Serialize(ref angularVelocity);
stream.Serialize(ref power);
}
else
{
// Receive latest state information
Vector3 position = Vector3.zero;
Vector3 velocity = Vector3.zero;
Vector3 acceleration = Vector3.zero;
Quaternion rotation = Quaternion.identity;
Vector3 angularVelocity = Vector3.zero;
float power = 0;
stream.Serialize(ref position);
stream.Serialize(ref velocity);
stream.Serialize(ref acceleration);
stream.Serialize(ref rotation);
stream.Serialize(ref angularVelocity);
stream.Serialize(ref power);
lastPosition = position;
lastVelocity = velocity;
lastAcceleration = acceleration;
lastRotation = rotation;
lastAngularVelocity = angularVelocity;
lastPower = power;
estPosition = lastPosition;
estVelocity = lastVelocity;
lastUpdateTimestamp = info.timestamp;
}
}
//Note: Send only what you actually want to consume/use, too!
//Note: If the owner doesn't write something into the stream, PUN won't send anything.
//</remarks>
//<param name="stream">Read or write stream to pass state of this GameObject (or whatever else).</param>
//<param name="info">Some info about the sender of this stream, who is the owner of this PhotonView (and GameObject).</param>
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
int gmState = (int)state;
int rdTmScre = redTeamScore;
int blTmScre = blueTeamScore;
int rdCptrs = redCaptures;
int blCptrs = blueCaptures;
float strtTime = startTime;
float gmTime = gameTime;
float gmTimeMax = gameTimeMax;
stream.Serialize(ref gmState);
stream.Serialize(ref rdTmScre);
stream.Serialize(ref blTmScre);
stream.Serialize(ref rdCptrs);
stream.Serialize(ref blCptrs);
stream.Serialize(ref strtTime);
stream.Serialize(ref gmTime);
stream.Serialize(ref gmTimeMax);
}
else
{
// Receive latest state information
int gmState = (int)state;
int rdTmScre = redTeamScore;
int blTmScre = blueTeamScore;
int rdCptrs = redCaptures;
int blCptrs = blueCaptures;
float strtTime = startTime;
float gmTime = gameTime;
float gmTimeMax = gameTimeMax;
stream.Serialize(ref gmState);
stream.Serialize(ref rdTmScre);
stream.Serialize(ref blTmScre);
stream.Serialize(ref rdCptrs);
stream.Serialize(ref blCptrs);
stream.Serialize(ref strtTime);
stream.Serialize(ref gmTime);
stream.Serialize(ref gmTimeMax);
state = (GameState)gmState;
redTeamScore = rdTmScre;
blueTeamScore = blTmScre;
redCaptures = rdCptrs;
blueCaptures = blCptrs;
startTime = strtTime;
gameTime = gmTime;
gameTimeMax = gmTimeMax;
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
stream.Serialize(ref ReadyTimer);
stream.Serialize(ref MatchStarted);
}
else
{
stream.Serialize(ref ReadyTimer);
stream.Serialize(ref MatchStarted);
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
stream.Serialize(ref nowtankHp); // 한번에 두개를 다 처리하는 부분 , HP 동기화 부분
//↓↓↓↓↓ HP게이지와 텍스트 HP를 HP양의 따라 색깔별로 구별하는 부분
if(pv.isMine) // 자기 자신만 하게끔 , 이걸 안하면 다른 플레이어의 HP가 한번 들어옴
{
textHp.text = nowtankHp.ToString();
hpColor = (float)nowtankHp / (float)tankHp;
if (hpColor <= 0.4f)
{
textHp.color = Color.red;
}
else if (hpColor <= 0.6f)
{
textHp.color = Color.magenta;
}
else if (hpColor <= 1.0f)
{
textHp.color = Color.green;
}
}
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
stream.Serialize(ref currentGate);
stream.Serialize(ref currentLap);
stream.Serialize(ref Ready);
}
else
{
stream.Serialize(ref currentGate);
stream.Serialize(ref currentLap);
stream.Serialize(ref Ready);
}
}
protected void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
//stream.isWriting
if (!rigidbody) return;
if (stream.isWriting)
{
syncPos = rigidbody.position;
syncRot = rigidbody.rotation;
syncVel = rigidbody.velocity;
syncAng = rigidbody.angularVelocity;
}
stream.Serialize(ref syncPos);
stream.Serialize(ref syncRot);
stream.Serialize(ref syncVel);
stream.Serialize(ref syncAng);
if (GameType.weapons)
{
stream.Serialize(ref distanceToCursor2);
stream.Serialize(ref TargetPlayerId);
}
if (stream.isReading)
{
if (Vector3.Distance(rigidbody.position, syncPos) > clampMax && Time.time - collisionTime > 1)
{
transform.position = syncPos;
transform.rotation = syncRot;
}
syncPos += syncVel * Mathf.Min(.2f, ping);
Debug.DrawLine(pos, syncPos, Color.yellow, 2);
rigidbody.velocity = syncVel;
rigidbody.angularVelocity = syncAng;
offsetPos = syncPos - pos;
if (Mathf.Abs(offsetPos.y) < .1f) offsetPos.y = 0;
offsetRot = syncRot * Quaternion.Inverse(rot);
}
ping = Mathf.Lerp(ping, Mathf.Max(0, (float)(PhotonNetwork.time - info.timestamp)), .1f);
}
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref moveSpeed);
stream.Serialize(ref myVelocity);
stream.Serialize(ref rotationSpeed);
stream.Serialize(ref isRotatingRight);
}
else
{
// Receive latest state information
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref moveSpeed);
stream.Serialize(ref myVelocity);
stream.Serialize(ref rotationSpeed);
stream.Serialize(ref isRotatingRight);
latestCorrectPos = pos;
latestCorrectRot = rot;
onUpdatePos = transform.localPosition;
onUpdateRot = transform.localRotation;
fraction = 0;
}
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
// Always send transform(depending on reliability of the network view)
if (stream.isWriting)
{
Vector2 pos = (Vector2)transform.localPosition;
Vector2 velocity = playerControl.velocity;
bool isFacingRight = playerControl.facingRight;
stream.Serialize(ref pos);
stream.Serialize(ref velocity);
stream.Serialize(ref isFacingRight);
}
// When receiving, buffer the information
else
{
// Receive latest state information
Vector2 pos = Vector2.zero;
Vector2 velocity = Vector2.zero;
bool isFacingRight = false;
stream.Serialize(ref pos);
stream.Serialize(ref velocity);
stream.Serialize(ref isFacingRight);
//Make proper face direction
playerControl.UpdateFaceDir(isFacingRight);
// Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1
for (int i = m_BufferedState.Length - 1; i >= 1; i--)
{
m_BufferedState[i] = m_BufferedState[i - 1];
}
// Save currect received state as 0 in the buffer, safe to overwrite after shifting
State state;
state.timestamp = info.timestamp;
state.pos = pos;
state.velocity = velocity;
m_BufferedState[0] = state;
// Increment state count but never exceed buffer size
m_TimestampCount = Mathf.Min(m_TimestampCount + 1, m_BufferedState.Length);
// Check integrity, lowest numbered state in the buffer is newest and so on
for (int i = 0; i < m_TimestampCount - 1; i++)
{
if (m_BufferedState[i].timestamp < m_BufferedState[i + 1].timestamp)
Debug.Log("State inconsistent");
}
}
}
protected void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
var v = vel;
var sk = skid;
syncPos = pos;
syncRot = rot;
stream.Serialize(ref v);
stream.Serialize(ref sk);
if (_Loader.dm)
{
stream.Serialize(ref distanceToCursor2);
stream.Serialize(ref TargetPlayerId);
}
stream.Serialize(ref syncPos);
stream.Serialize(ref syncRot);
//}
if (stream.isReading)
{
if (stopAudio != null)
stopAudio.volume = sk;
vel = v;
//ping = Mathf.Max(0, (float)(PhotonNetwork.time - info.timestamp));
ping = Mathf.Lerp(ping, Mathf.Max(0, (float)(PhotonNetwork.time - info.timestamp)), .1f);
if (_Loader.mpCollisions)
{
if (Vector3.Distance(rigidbody.position, syncPos) > clampMax)
{
transform.position = syncPos;
transform.rotation = syncRot;
}
else
{
var c = Time.time - collisionTime > 1;
if (Vector3.Distance(rigidbody.position, syncPos) > clampMax && c)
{
transform.position = syncPos;
transform.rotation = syncRot;
}
syncPos += vel * ping;
Debug.DrawLine(pos, syncPos, Color.yellow, 2);
rigidbody.velocity = vel;
offsetPos = syncPos - pos;
offsetRot = syncRot * Quaternion.Inverse(rot);
}
Debug.DrawLine(pos, syncPos, Color.yellow, 2);
}
else
{
for (int i = m_BufferedState.Length - 1; i >= 1; i--)
m_BufferedState[i] = m_BufferedState[i - 1];
float f = Mathf.Min(2, (float)(PhotonNetwork.time - m_BufferedState[0].timestamp) + .2f);
interpolationBackTime = setting.lagNetw ? 3 : Mathf.Lerp(interpolationBackTime, f, interpolationBackTime > f ? .01f : .5f);
State state;
state.timestamp = info.timestamp;
state.pos = syncPos;
state.rot = syncRot;
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");
}
}
}
