private void DestroyGameObject(NetWorker sender)
{
MainThreadManager.Run(() => { try { Destroy(gameObject); } catch { } });
networkObject.onDestroy -= DestroyGameObject;
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (PauseScreenNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("pauseOrResume", pauseOrResume, typeof(bool));
networkObject.RegisterRpc("showTerminateNotification", showTerminateNotification);
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
uint newId = obj.NetworkId + 1;
ProcessOthers(gameObject.transform, ref newId);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (ChatManagerNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("SendMessage", SendMessage, typeof(string), typeof(string));
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
uint newId = obj.NetworkId + 1;
ProcessOthers(gameObject.transform, ref newId);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
bool changePos = (transformFlags & 0x01) != 0;
bool changeRotation = (transformFlags & 0x02) != 0;
if (changePos || changeRotation)
{
MainThreadManager.Run(() =>
{
if (changePos)
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
}
if (changeRotation)
{
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
}
});
}
}
}
MainThreadManager.Run(() =>
{
gameObject.SetActive(true);
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (PlayerNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("UpdateName", UpdateName, typeof(string));
networkObject.RegisterRpc("UpdatePing", UpdatePing, typeof(int));
networkObject.RegisterRpc("UpdateKills", UpdateKills, typeof(int));
networkObject.RegisterRpc("Shoot", Shoot, typeof(Vector3), typeof(Vector3));
networkObject.RegisterRpc("TakeDamage", TakeDamage, typeof(int), typeof(uint), typeof(Vector3), typeof(Vector3));
networkObject.RegisterRpc("UpdateId", UpdateId, typeof(uint));
networkObject.RegisterRpc("Spawn", Spawn, typeof(Vector3), typeof(Quaternion));
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
ProcessOthers(gameObject.transform, obj.NetworkId + 1);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (NetworkCameraNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
MainThreadManager.Run(NetworkStart);
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
ProcessOthers(gameObject.transform, obj.NetworkId + 1);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata == null)
{
return;
}
byte transformFlags = obj.Metadata[0];
if (transformFlags == 0)
{
return;
}
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (NetworkedPlayerNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("Attack", Attack);
networkObject.RegisterRpc("ChangeName", ChangeName, typeof(string));
networkObject.RegisterRpc("Jump", Jump, typeof(bool));
networkObject.RegisterRpc("Land", Land);
networkObject.RegisterRpc("Die", Die, typeof(string), typeof(int));
networkObject.RegisterRpc("TryHit", TryHit, typeof(uint), typeof(string), typeof(int), typeof(Vector3));
networkObject.RegisterRpc("Init", Init, typeof(int), typeof(Vector3));
networkObject.RegisterRpc("ToggleFlag", ToggleFlag, typeof(bool));
networkObject.RegisterRpc("Knockback", Knockback, typeof(Vector3));
networkObject.RegisterRpc("DebugAttack", DebugAttack);
networkObject.RegisterRpc("Hitmarker", Hitmarker);
networkObject.RegisterRpc("Respawn", Respawn);
networkObject.RegisterRpc("Dash", Dash);
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
uint newId = obj.NetworkId + 1;
ProcessOthers(gameObject.transform, ref newId);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (TestNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("FuncBlank", FuncBlank);
networkObject.RegisterRpc("FuncByte", FuncByte, typeof(byte));
networkObject.RegisterRpc("FuncChar", FuncChar, typeof(char));
networkObject.RegisterRpc("FuncShort", FuncShort, typeof(short));
networkObject.RegisterRpc("FuncUShort", FuncUShort, typeof(ushort));
networkObject.RegisterRpc("FuncBool", FuncBool, typeof(bool));
networkObject.RegisterRpc("FuncInt", FuncInt, typeof(int));
networkObject.RegisterRpc("FuncUInt", FuncUInt, typeof(uint));
networkObject.RegisterRpc("FuncFloat", FuncFloat, typeof(float));
networkObject.RegisterRpc("FuncLong", FuncLong, typeof(long));
networkObject.RegisterRpc("FuncULong", FuncULong, typeof(ulong));
networkObject.RegisterRpc("FuncDouble", FuncDouble, typeof(double));
networkObject.RegisterRpc("FuncString", FuncString, typeof(string));
networkObject.RegisterRpc("FuncByteArray", FuncByteArray, typeof(byte[]));
networkObject.RegisterRpc("FuncAll", FuncAll, typeof(byte), typeof(char), typeof(short), typeof(ushort), typeof(bool), typeof(int), typeof(uint), typeof(float), typeof(long), typeof(ulong), typeof(double), typeof(string), typeof(byte[]));
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
ProcessOthers(gameObject.transform, obj.NetworkId + 1);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata == null)
{
return;
}
byte transformFlags = obj.Metadata[0];
if (transformFlags == 0)
{
return;
}
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (CubeForgeGameNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("InitializeMap", InitializeMap, typeof(Vector3), typeof(Vector3), typeof(byte[]));
networkObject.RegisterRpc("CreatePrimitive", CreatePrimitive, typeof(byte), typeof(Vector3));
networkObject.RegisterRpc("DestroyPrimitive", DestroyPrimitive, typeof(Vector3));
networkObject.RegisterRpc("TestMe", TestMe, typeof(string));
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
ProcessOthers(gameObject.transform, obj.NetworkId + 1);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata == null)
{
return;
}
byte transformFlags = obj.Metadata[0];
if (transformFlags == 0)
{
return;
}
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public void Host()
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
hostButton.interactable = false;
server = new UDPServer(maxPlayers);
((UDPServer)server).Connect(ipAddress, (ushort)portNumber);
server.playerTimeout += (player, sender) =>
{
Debug.Log("Player " + player.NetworkId + " timed out.");
};
server.playerConnected += (player, sender) =>
{
MainThreadManager.Run(() =>
{
Debug.Log("Server: Player connected");
soundManager.Play(VGCSoundEffects.PlayerConnected);
});
};
server.playerDisconnected += (player, sender) =>
{
MainThreadManager.Run(() =>
{
Debug.Log("Server: Player disconnected");
soundManager.Play(VGCSoundEffects.PlayerDisconnected);
//Loop through all players and find the player who disconnected, store all it's networkobjects to a list
List <NetworkObject> toDelete = new List <NetworkObject>();
foreach (var no in sender.NetworkObjectList)
{
if (no.Owner == player)
{
//Found him
toDelete.Add(no);
}
}
//Remove the actual network object outside of the foreach loop, as we would modify the collection at runtime elsewise. (could also use a return, too late)
if (toDelete.Count > 0)
{
for (int i = toDelete.Count - 1; i >= 0; i--)
{
sender.NetworkObjectList.Remove(toDelete[i]);
toDelete[i].Destroy();
}
}
/*
* // Удаляем игроков
* GameObject[] players = GameObject.FindGameObjectsWithTag("Player");
* if (players.Length > 0) {
* for (int i = 0; i < players.Length; i++) {
* if (players[i].GetComponent<Player>().ID == sender.) {
* GameObject.Destroy(players[i]);
* break;
* }
* }
* }*/
});
};
server.playerAccepted += (player, sender) =>
{
MainThreadManager.Run(() =>
{
Debug.Log("Server: Player accepted");
});
};
Connected(server);
Debug.Log("Connected(server)");
// Старт игры для хоста
mainMenuPanel.gameObject.SetActive(false);
inGamePanel.gameObject.SetActive(true);
NetworkManager.Instance.InstantiatePlayer();
// Старт сетевой игры как объекта
NetworkManager.Instance.InstantiateGame();
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (NetworkManagerNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("sendPath", sendPath, typeof(string));
networkObject.RegisterRpc("resetLevel", resetLevel);
networkObject.RegisterRpc("victory", victory);
networkObject.RegisterRpc("setLevel", setLevel, typeof(int));
networkObject.RegisterRpc("setInkLevel", setInkLevel, typeof(float));
networkObject.RegisterRpc("setAttempts", setAttempts, typeof(int));
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
uint newId = obj.NetworkId + 1;
ProcessOthers(gameObject.transform, ref newId);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (PlayerNetworkObject)obj;
networkObject.AttachedBehavior = this;
/*
* base.SetupHelperRpcs(networkObject);
* networkObject.RegisterRpc("Shoot", Shoot, typeof(Vector3), typeof(Vector3));
* networkObject.RegisterRpc("Die", Die, typeof(string));
* networkObject.RegisterRpc("SwitchWeapon", SwitchWeapon, typeof(int));
* networkObject.RegisterRpc("TakeDamage", TakeDamage, typeof(int), typeof(Vector3), typeof(Vector3));
* networkObject.RegisterRpc("SetupPlayer", SetupPlayer, typeof(int), typeof(string));
*/
networkObject.onDestroy += DestroyGameObject;
///if (!obj.IsOwner)
if (networkObject.IsRemote)
{
if (!skipAttachIds.ContainsKey((uint)networkObject.frameSender.UID))
{
ProcessOthers(gameObject.transform, (uint)networkObject.frameSender.UID + 1);
}
else
{
skipAttachIds.Remove((uint)networkObject.frameSender.UID);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
}
MainThreadManager.Run(() =>
{
NetworkStart();
if (!networkObject.IsRemote)
{
networkObject.Networker.FlushCreateActions(networkObject);
}
});
}
public override void Initialize(NetworkObject obj)
{
// We have already initialized this object
if (networkObject != null && networkObject.AttachedBehavior != null)
{
return;
}
networkObject = (MasterNetworkObject)obj;
networkObject.AttachedBehavior = this;
base.SetupHelperRpcs(networkObject);
networkObject.RegisterRpc("SendMessage", SendMessage, typeof(string));
networkObject.RegisterRpc("AddActivePlayer", AddActivePlayer, typeof(string), typeof(bool));
networkObject.RegisterRpc("RemoveActivePlayer", RemoveActivePlayer, typeof(string));
networkObject.RegisterRpc("ClientLoadMothership", ClientLoadMothership, typeof(string));
networkObject.RegisterRpc("StartTravel", StartTravel, typeof(string));
networkObject.RegisterRpc("CheckTravel", CheckTravel);
networkObject.RegisterRpc("EnterOrbit", EnterOrbit, typeof(int));
networkObject.RegisterRpc("LeaveOrbit", LeaveOrbit);
networkObject.RegisterRpc("ColonizePlanet", ColonizePlanet);
networkObject.RegisterRpc("CanColonize", CanColonize);
networkObject.RegisterRpc("LandOnPlanet", LandOnPlanet);
networkObject.RegisterRpc("CanLandOnPlanet", CanLandOnPlanet);
networkObject.RegisterRpc("ClientEnterOrbit", ClientEnterOrbit);
networkObject.RegisterRpc("SendCallbackToClient", SendCallbackToClient, typeof(string), typeof(bool), typeof(string));
networkObject.RegisterRpc("SendEventTrigger", SendEventTrigger, typeof(string), typeof(bool));
networkObject.RegisterRpc("CalculateTravelTime", CalculateTravelTime, typeof(int), typeof(bool));
networkObject.RegisterRpc("SendBmcRequest", SendBmcRequest, typeof(string), typeof(string));
networkObject.RegisterRpc("SendBmcCallbackToClient", SendBmcCallbackToClient, typeof(string), typeof(string));
networkObject.RegisterRpc("StartMiningMission", StartMiningMission, typeof(byte), typeof(byte), typeof(byte), typeof(bool));
networkObject.RegisterRpc("LogBook", LogBook, typeof(int), typeof(string));
networkObject.onDestroy += DestroyGameObject;
if (!obj.IsOwner)
{
if (!skipAttachIds.ContainsKey(obj.NetworkId))
{
ProcessOthers(gameObject.transform, obj.NetworkId + 1);
}
else
{
skipAttachIds.Remove(obj.NetworkId);
}
}
if (obj.Metadata != null)
{
byte transformFlags = obj.Metadata[0];
if (transformFlags != 0)
{
BMSByte metadataTransform = new BMSByte();
metadataTransform.Clone(obj.Metadata);
metadataTransform.MoveStartIndex(1);
if ((transformFlags & 0x01) != 0 && (transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() =>
{
transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform);
transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform);
});
}
else if ((transformFlags & 0x01) != 0)
{
MainThreadManager.Run(() => { transform.position = ObjectMapper.Instance.Map <Vector3>(metadataTransform); });
}
else if ((transformFlags & 0x02) != 0)
{
MainThreadManager.Run(() => { transform.rotation = ObjectMapper.Instance.Map <Quaternion>(metadataTransform); });
}
}
}
MainThreadManager.Run(() =>
{
NetworkStart();
networkObject.Networker.FlushCreateActions(networkObject);
});
}
