/* 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) {
//This is executed on the owner of the networkview
//The owner sends it's color over the network
//send color
Vector3 tempcolor = new Vector3(gameObject.GetComponent<Renderer>().material.color.r,gameObject.GetComponent<Renderer>().material.color.g,gameObject.GetComponent<Renderer>().material.color.b);
stream.Serialize (ref tempcolor);//"Encode" it, and send it
} else {
//Executed on all non-owners
//receive a color and set the object to it
//get color
Vector3 tempcolor = Vector3.zero;
Color colorReceive = Color.black;
stream.Serialize (ref tempcolor);
colorReceive = new Color(tempcolor.x, tempcolor.y, tempcolor.z, 1.0f);
//We've just recieved the current servers position of this object in 'posReceive'.
renderer.material.color = colorReceive;
//To reduce laggy movement a bit you could comment the line above and use position lerping below instead:
//transform.position = Vector3.Lerp(transform.position, posReceive, 0.9f); //"lerp" to the posReceive by 90%
//It would be even better to save the last received server position and lerp to it in Update because it is executed more often than OnSerializeNetworkView
}
}
public void OnNetworkInstantiate(UnityEngine.NetworkMessageInfo a)
{
if (fn != null)
{
fn.invoke(gameObject, a);
}
}
void OnNetworkInstantiate(NetworkMessageInfo msg)
{
if (networkView.isMine)
{
this.enabled = false;
}
}
void OnNetworkInstantiate(NetworkMessageInfo info)
{
if(networkView.isMine)
{
StartCoroutine(DestroyAfter(duration));
}
}
static void NetworkMessageInfo_networkView(JSVCall vc)
{
UnityEngine.NetworkMessageInfo _this = (UnityEngine.NetworkMessageInfo)vc.csObj;
var result = _this.networkView;
JSMgr.datax.setObject((int)JSApi.SetType.Rval, result);
}
public void OnNetworkInstantiate(NetworkMessageInfo info)
{
transform.eulerAngles = new Vector3(90f, transform.eulerAngles.y, transform.eulerAngles.z);
enabled = false;
gameObject.renderer.enabled = false;
Init();
}
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;
}
}
// fields
// properties
static void NetworkMessageInfo_timestamp(JSVCall vc)
{
UnityEngine.NetworkMessageInfo _this = (UnityEngine.NetworkMessageInfo)vc.csObj;
var result = _this.timestamp;
JSApi.setDouble((int)JSApi.SetType.Rval, (System.Double)(result));
}
public void OnSerializeNetworkView2D(BitStream stream, NetworkMessageInfo info,
UnitActionCommand pUnitActionCommand, bool pIsAlive)
{
Transform lTransform = characterController.transform;
Vector3 lData = Vector3.zero;
//---------------------------------------------------
if (stream.isWriting)
{
lData = lTransform.position;
lData.z = yVelocity;
}
//---------------------------------------------------
stream.Serialize(ref lData);
//---------------------------------------------------
if (stream.isReading)
{
yVelocity = lData.z;
lData.z = 0f;
lTransform.position = lData;
var lDeltaTime = (float)(Network.time - info.timestamp);
if (lDeltaTime > 0.02f)
update2D(pUnitActionCommand, UnitFace.getValue(pUnitActionCommand.face),
pIsAlive, lDeltaTime * Time.timeScale);
lastUpdateTime = Time.time;
}
}
public void OnSerializeNetworkView(UnityEngine.BitStream a, UnityEngine.NetworkMessageInfo b)
{
if (fn != null)
{
fn.invoke(gameObject, a, b);
}
}
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 ReceiveMessage(string message, NetworkMessageInfo netInfo)
{
//Debug.Log(message);
string tag = message.Split(':')[0];
string msg = message.Split(':')[1];
switch (tag)
{
case "Began":
gesture.Begin(float.Parse(msg.Split(',')[0]), float.Parse(msg.Split(',')[1]));
break;
case "Moved":
gesture.Move(float.Parse(msg.Split(',')[0]), float.Parse(msg.Split(',')[1]));
break;
case "Ended":
gesture.End(float.Parse(msg.Split(',')[0]), float.Parse(msg.Split(',')[1]));
break;
case "Choose Candidate":
lexicon.Accept(int.Parse(msg));
break;
case "Keyboard Size Msg":
lexicon.UpdateSizeMsg(msg);
break;
case "Delete":
//lexicon.Delete();
break;
default:
break;
}
}
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);
}
}
void OnSerializeNetworkView( BitStream stream, NetworkMessageInfo info )
{
Vector3 syncPosition = Vector3.zero; // для синхронизации позиции
Vector3 syncVelocity = Vector3.zero; // для синхронизации действующей силы
Quaternion syncRotation = Quaternion.identity; // для синхронизации поворота
if ( stream.isWriting ) { // если отправляем в сеть то считываем данные обьекта и отправляем
syncPosition = rigidbody.position;
stream.Serialize( ref syncPosition );
syncPosition = rigidbody.velocity;
stream.Serialize( ref syncVelocity );
syncRotation = rigidbody.rotation;
stream.Serialize( ref syncRotation );
} else { // иначе считываем из сети
stream.Serialize( ref syncPosition );
stream.Serialize( ref syncVelocity );
stream.Serialize( ref syncRotation );
syncTime = 0f; // сбрасываем время синхронизации
syncDelay = Time.time - lastSynchronizationTime; // получаем дельту придыдущей синхронизации
lastSynchronizationTime = Time.time; // записываем новое время последней синхронизации
syncEndPosition = syncPosition + syncVelocity * syncDelay; // конечная точка в которую двигаеться обьект
syncStartPosition = rigidbody.position; // начальная точка равна текущей позиции
syncEndRotation = syncRotation; // конечный поворот
syncStartRotation = rigidbody.rotation; // начальный поворот
}
}
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)
{
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;
}
*/
}
}
public void RecvHealth(byte[] pckData, NetworkMessageInfo info)
{
//ServerCheck
S2C.SetStructureHealth pck = new S2C.SetStructureHealth();
pck.DeserializeFromBytes(pckData);
TileManager.Inst.Get(pck.m_ID).RecvHealth(pck);
}
// 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)
{
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 OnNetworkInstantiate(NetworkMessageInfo info)
{
Debug.Log("New object instantiated by " + info.sender);
string sender = info.sender.ToString();
if (!Network.isServer) {
if (!sender.Equals ("-1")) {
Debug.Log("healer instant cams = " + Camera.allCameras.Length);
for (int i = 0; i < Camera.allCameras.Length; i++) {
Debug.Log ("Camera[" + i + "] = " + Camera.allCameras[i]);
}
//Camera.allCameras[Camera.allCameras.Length - 1].enabled = false;
Camera.allCameras[1].enabled = false;
GameObject[] launchers = GameObject.FindGameObjectsWithTag("Launcher");
Debug.Log ("Number of launchers = " + launchers.Length);
launchers[launchers.Length - 1].SetActive(false);
} else {
Camera.allCameras[1].enabled = false;
}
}
/*Debug.Log("cams = " + Camera.allCameras.Length);
string sender = info.sender.ToString();
GameObject[] launchers = GameObject.FindGameObjectsWithTag("Launcher");
Debug.Log ("Number of launchers = " + launchers.Length);
if (!Network.isServer) {
if (sender.Equals ("-1")) {
Camera.allCameras[1].enabled = false;
Camera.allCameras[0].enabled = true;
} else {
Camera.allCameras[Camera.allCameras.Length-1].enabled = false;
launchers[launchers.Length - 1].SetActive(false);
}
}*/
}
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;
}
}
}
protected virtual void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (selected == _PlayerOwn || stream.isReading)
{
if (stream.isWriting)
{
syncPos = pos;
syncRot = rot;
//syncVel = controller.velocity;
}
stream.Serialize(ref syncPos);
stream.Serialize(ref syncRot);
//stream.Serialize(ref syncVel);
if (stream.isReading)
{
if (syncPos == Vector3.zero)
{ }
else
{
pos = syncPos;
rot = syncRot;
}
//vel = syncVel;
}
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if(stream.isWriting) {
//Position Synchronization
Vector3 position = transform.position; stream.Serialize(ref position);
//Rotation Synchronization
Quaternion rotation = transform.rotation; stream.Serialize(ref rotation);
//Current Movement
Vector3 directionVector = motor.inputMoveDirection;
stream.Serialize(ref directionVector);
}
else {
//Position Synchronization
Vector3 position = Vector3.zero; stream.Serialize(ref position);
transform.position = position;
//Rotation synchronization
Quaternion rotation = Quaternion.identity; stream.Serialize(ref rotation);
transform.rotation = rotation;
//Current Movement
Vector3 directionVector = Vector3.zero;
stream.Serialize(ref directionVector);
motor.inputMoveDirection = directionVector;
}
}
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 OnNetworkInstantiate(NetworkMessageInfo info)
{
if (networkView.isMine)
{
// Disable interpolated transform, we control the movement on this client
GetComponent<NetworkInterpolatedTransform>().enabled = false;
}
else
{
name += "Remote";
if (_owner == Network.player)
{
// note; we should enable some prediction components here
GetComponent<NetworkInterpolatedTransform>().enabled = true;
rigidbody.useGravity = false;
collider.enabled = false;
}
else
{
GetComponent<NetworkInterpolatedTransform>().enabled = true;
rigidbody.useGravity = false;
collider.enabled = false;
}
}
// we will decide when the object is destroyed
autoDestroy = false;
}
/*
[RPC]
public void reeling(float angle)
{
}
*/
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (stream.isWriting) {
} else {
// if (boat)
// transform.position = new Vector3(transform.position.x, boat.transform.position.y + boatOffsetY, transform.position.z);
/* Quaternion receivedRot = new Quaternion(0, 0, 0, 0);
stream.Serialize(ref receivedRot);
Quaternion rotationToUse = receivedRot;
transform.rotation = rotationToUse;*/
Vector3 receivedRot = Vector3.zero;
stream.Serialize (ref receivedRot);
acceRotationVector = receivedRot;
Quaternion rotation = Quaternion.LookRotation (receivedRot);
float angle = Quaternion.Angle (transform.rotation, rotation);
rotZ = rotation.eulerAngles.z;
rotX = rotation.eulerAngles.x;
rotY = rotation.eulerAngles.y;
if (angle > rotationBreak) {
transform.rotation = Quaternion.Lerp (transform.rotation, rotation, Time.deltaTime * rotationSpeed);
// Works -> transform.rotation = Quaternion.Lerp(transform.rotation, rotation, Time.deltaTime * rotationSpeed);
}
}
}
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)
{
if (!stream.isWriting)
{
}
}
void GiveMeACart(string cartModel, string ballModel, string characterModel, NetworkMessageInfo info)
{
// create new buggy for the new guy - his must be done on the server otherwise collisions wont work!
Vector3 spawnLocation = new Vector3(0,5,0);
Vector3 velocity = new Vector3(0,0,0);
// instantiate the prefabs
GameObject cartContainerObject = (Instantiate(Resources.Load(cartModel), spawnLocation, Quaternion.identity) as GameObject);
GameObject ballGameObject = Instantiate(Resources.Load(ballModel), spawnLocation + new Vector3(3,0,0), Quaternion.identity) as GameObject;
GameObject characterGameObject = Instantiate(Resources.Load(characterModel), spawnLocation + new Vector3(0,-1,0), Quaternion.identity) as GameObject;
GameObject cartGameObject = cartContainerObject.transform.FindChild ("buggy").gameObject;
// set buggy as characters parent
characterGameObject.transform.parent = cartGameObject.transform;
// create and set viewIDs
NetworkViewID cartViewIDTransform = Network.AllocateViewID();
NetworkView cgt = cartContainerObject.AddComponent("NetworkView") as NetworkView;
cgt.observed = cartContainerObject.transform;
cgt.viewID = cartViewIDTransform;
cgt.stateSynchronization = NetworkStateSynchronization.Unreliable;
NetworkViewID cartViewIDRigidbody = Network.AllocateViewID();
NetworkView cgr = cartGameObject.AddComponent("NetworkView") as NetworkView;
cgr.observed = cartGameObject.rigidbody;
cgr.viewID = cartViewIDRigidbody;
cgr.stateSynchronization = NetworkStateSynchronization.Unreliable;
NetworkViewID ballViewID = Network.AllocateViewID();
ballGameObject.networkView.viewID = ballViewID;
NetworkViewID characterViewID = Network.AllocateViewID();
characterGameObject.networkView.viewID = characterViewID;
// tell everyone else about it
networkView.RPC("SpawnPrefab", RPCMode.Others, cartViewIDTransform, spawnLocation, velocity, cartModel);
networkView.RPC("SpawnPrefab", RPCMode.Others, ballViewID, spawnLocation, velocity, ballModel);
networkView.RPC("SpawnPrefab", RPCMode.Others, characterViewID, spawnLocation, velocity, characterModel);
// tell all players this is a player and not some random objects
networkView.RPC("SpawnPlayer", RPCMode.Others, cartViewIDTransform, cartViewIDRigidbody, ballViewID, characterViewID, 0, info.sender);
// tell the player it's theirs
networkView.RPC("ThisOnesYours", info.sender, cartViewIDTransform, ballViewID, characterViewID);
// create a PlayerInfo for it
PlayerInfo newGuy = new PlayerInfo();
newGuy.cartModel = cartModel;
newGuy.cartContainerObject = cartContainerObject;
newGuy.cartGameObject = cartGameObject;
newGuy.cartViewIDTransform = cartViewIDTransform;
newGuy.cartViewIDRigidbody = cartViewIDRigidbody;
newGuy.ballModel = ballModel;
newGuy.ballGameObject = ballGameObject;
newGuy.ballViewID = ballViewID;
newGuy.characterModel = characterModel;
newGuy.characterGameObject = characterGameObject;
newGuy.characterViewID = characterViewID;
newGuy.currentMode = 0; // set them in buggy
newGuy.player = info.sender;
// add it to the lists
nvs.players.Add(newGuy);
}
public override bool controlSelectedObjects(bool select, NetworkViewID viewID, NetworkMessageInfo info)
{
if (isObjectAccessGranted(info.sender))
{
if (base.controlSelectedObjects(select,viewID,info))
{
/* ------------------ VRUE Tasks START -------------------
* - set the current NetworkPlayer to the player calling the RPC-method or
* the default NetworkPlayer depending on "select"
----------------------------------------------------------------- */
//return true;//replace me
if (select)
{
currentAccessPlayer = info.sender;
}
else
{
currentAccessPlayer = defaultAccessPlayer;
}
return true;
// ------------------ VRUE Tasks END ----------------------------
}
}
return false;
}
void ReceiveReply(NetworkMessageInfo info)
{
if(!connectedStatus.ContainsKey(info.sender))
connectedStatus.Add(info.sender, true);
else
connectedStatus[info.sender] = true;
}
//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;
}
}
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);
}
}
public override void ReceiveRPC(Distance::BitStreamReader bitStreamReader, UnityEngine.NetworkMessageInfo info)
{
T data = DeserializeRPC(bitStreamReader);
foreach (var handler in subscriptions)
{
handler(data, info);
}
}
public override void ReceiveRPC(Distance::BitStreamReader bitStreamReader, UnityEngine.NetworkMessageInfo info)
{
T data = DeserializeRPC(bitStreamReader);
foreach (var conn in subscriptions)
{
conn.Handler(data);
}
ReceiveInstanced(instance, data);
}
public abstract void ReceiveSerializeEvent(byte[] bytes, UnityEngine.NetworkMessageInfo info);
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
}
public void OnSerializeNetworkView(UnityEngine.BitStream a, UnityEngine.NetworkMessageInfo b)
{
RunFunctions(a, b);
}
public virtual void ReceiveRPC(Distance::BitStreamReader bitStreamReader, UnityEngine.NetworkMessageInfo info)
{
Log.WriteLine("Received RPC to unimplemented NetworkEvent");
}
void OnNetworkInstantiate(NetworkMessageInfo info)
{
}
public void OnNetworkInstantiate(UnityEngine.NetworkMessageInfo a)
{
RunFunctions(a);
}