/// <summary>
/// TODO
/// </summary>
/// <param name="hash"></param>
public void SetTrigger(int hash)
{
if (IsOwner)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteInt32Packed(hash);
if (IsServer)
{
if (EnableProximity)
{
List <ulong> clientsInProximity = new List <ulong>();
foreach (KeyValuePair <ulong, NetworkedClient> client in NetworkingManager.Singleton.ConnectedClients)
{
if (Vector3.Distance(transform.position, client.Value.PlayerObject.transform.position) <= ProximityRange)
{
clientsInProximity.Add(client.Key);
}
}
InvokeClientRpcPerformance(ApplyAnimTriggerMsg, clientsInProximity, stream);
}
else
{
InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimTriggerMsg, OwnerClientId, stream);
}
}
else
{
InvokeServerRpcPerformance(SubmitAnimTriggerMsg, stream);
}
}
}
}
}
/// <summary>
/// Returns a base64 encoded version of the config
/// </summary>
/// <returns></returns>
public string ToBase64()
{
NetworkConfig config = this;
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt16Packed(config.ProtocolVersion);
writer.WriteUInt16Packed((ushort)config.RegisteredScenes.Count);
for (int i = 0; i < config.RegisteredScenes.Count; i++)
{
writer.WriteString(config.RegisteredScenes[i]);
}
writer.WriteInt32Packed(config.ReceiveTickrate);
writer.WriteInt32Packed(config.MaxReceiveEventsPerTickRate);
writer.WriteInt32Packed(config.EventTickrate);
writer.WriteInt32Packed(config.ClientConnectionBufferTimeout);
writer.WriteBool(config.ConnectionApproval);
writer.WriteInt32Packed(config.SecondsHistory);
writer.WriteBool(config.EnableEncryption);
writer.WriteBool(config.SignKeyExchange);
writer.WriteInt32Packed(config.LoadSceneTimeOut);
writer.WriteBool(config.EnableTimeResync);
writer.WriteBool(config.EnsureNetworkedVarLengthSafety);
writer.WriteBits((byte)config.RpcHashSize, 2);
writer.WriteBool(ForceSamePrefabs);
writer.WriteBool(UsePrefabSync);
writer.WriteBool(EnableSceneManagement);
writer.WriteBool(RecycleNetworkIds);
writer.WriteSinglePacked(NetworkIdRecycleDelay);
writer.WriteBool(EnableNetworkedVar);
writer.WriteBool(AllowRuntimeSceneChanges);
writer.WriteBool(EnableNetworkLogs);
stream.PadStream();
return(Convert.ToBase64String(stream.ToArray()));
}
}
}
internal static void SpawnObject(NetworkedObject netObject, uint?clientOwnerId = null, Stream payload = null, bool destroyWithScene = false)
{
if (netObject.isSpawned)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Object already spawned");
}
return;
}
else if (!netManager.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Only server can spawn objects");
}
return;
}
else if (SpawnManager.GetNetworkedPrefabIndexOfName(netObject.NetworkedPrefabName) == -1)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The prefab name " + netObject.NetworkedPrefabName + " does not exist as a networkedPrefab");
}
return;
}
else if (!netManager.NetworkConfig.HandleObjectSpawning)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("NetworkConfig is set to not handle object spawning");
}
return;
}
uint netId = GetNetworkObjectId();
netObject.NetworkId = netId;
SpawnedObjects.Add(netId, netObject);
SpawnedObjectsList.Add(netObject);
netObject.isSpawned = true;
netObject.destroyWithScene = destroyWithScene;
netObject.sceneSpawnedInIndex = NetworkSceneManager.CurrentActiveSceneIndex;
if (clientOwnerId != null)
{
netObject.OwnerClientId = clientOwnerId.Value;
NetworkingManager.singleton.ConnectedClients[clientOwnerId.Value].OwnedObjects.Add(netObject);
}
if (payload == null)
{
netObject.InvokeBehaviourNetworkSpawn(null);
}
else
{
netObject.InvokeBehaviourNetworkSpawn(payload);
}
foreach (var client in netManager.ConnectedClients)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteBool(false);
writer.WriteUInt32Packed(netObject.NetworkId);
writer.WriteUInt32Packed(netObject.OwnerClientId);
writer.WriteUInt64Packed(netObject.NetworkedPrefabHash);
writer.WriteBool(netObject.destroyWithScene == null ? true : netObject.destroyWithScene.Value);
writer.WriteBool(netObject.SceneDelayedSpawn);
writer.WriteUInt32Packed(netObject.sceneSpawnedInIndex);
writer.WriteSinglePacked(netObject.transform.position.x);
writer.WriteSinglePacked(netObject.transform.position.y);
writer.WriteSinglePacked(netObject.transform.position.z);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.z);
writer.WriteBool(payload != null);
if (payload != null)
{
writer.WriteInt32Packed((int)payload.Length);
}
netObject.WriteNetworkedVarData(stream, client.Key);
if (payload != null)
{
stream.CopyFrom(payload);
}
InternalMessageHandler.Send(client.Key, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
}
}
internal static void WriteSpawnCallForObject(Serialization.BitStream stream, ulong clientId, NetworkedObject netObject, Stream payload)
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteBool(netObject.IsPlayerObject);
writer.WriteUInt64Packed(netObject.NetworkId);
writer.WriteUInt64Packed(netObject.OwnerClientId);
NetworkedObject parent = null;
if (!netObject.AlwaysReplicateAsRoot && netObject.transform.parent != null)
{
parent = netObject.transform.parent.GetComponent <NetworkedObject>();
}
if (parent == null)
{
writer.WriteBool(false);
}
else
{
writer.WriteBool(true);
writer.WriteUInt64Packed(parent.NetworkId);
}
if (!NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
writer.WriteUInt64Packed(netObject.PrefabHash);
}
else
{
writer.WriteBool(netObject.IsSceneObject == null ? true : netObject.IsSceneObject.Value);
if (netObject.IsSceneObject == null || netObject.IsSceneObject.Value)
{
writer.WriteUInt64Packed(netObject.NetworkedInstanceId);
}
else
{
writer.WriteUInt64Packed(netObject.PrefabHash);
}
}
if (netObject.IncludeTransformWhenSpawning == null || netObject.IncludeTransformWhenSpawning(clientId))
{
writer.WriteBool(true);
writer.WriteSinglePacked(netObject.transform.position.x);
writer.WriteSinglePacked(netObject.transform.position.y);
writer.WriteSinglePacked(netObject.transform.position.z);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.z);
}
else
{
writer.WriteBool(false);
}
writer.WriteBool(payload != null);
if (payload != null)
{
writer.WriteInt32Packed((int)payload.Length);
}
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
netObject.WriteNetworkedVarData(stream, clientId);
netObject.WriteSyncedVarData(stream, clientId);
}
if (payload != null)
{
stream.CopyFrom(payload);
}
}
}
//Server only
internal static void SpawnPlayerObject(NetworkedObject netObject, uint clientId, Stream payload = null)
{
if (netObject.isSpawned)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Object already spawned");
}
return;
}
else if (!netManager.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Only server can spawn objects");
}
return;
}
else if (!netManager.NetworkConfig.NetworkPrefabIds.ContainsKey(netObject.NetworkedPrefabName))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The prefab name " + netObject.NetworkedPrefabName + " does not exist as a networkedPrefab");
}
return;
}
else if (!netManager.NetworkConfig.HandleObjectSpawning)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("NetworkConfig is set to not handle object spawning");
}
return;
}
else if (netManager.ConnectedClients[clientId].PlayerObject != null)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Client already have a player object");
}
return;
}
uint netId = GetNetworkObjectId();
netObject.NetworkId = netId;
SpawnedObjects.Add(netId, netObject);
SpawnedObjectsList.Add(netObject);
netObject.isSpawned = true;
netObject.sceneObject = false;
netObject.isPlayerObject = true;
netManager.ConnectedClients[clientId].PlayerObject = netObject;
if (payload == null)
{
netObject.InvokeBehaviourNetworkSpawn(null);
}
else
{
netObject.InvokeBehaviourNetworkSpawn(payload);
}
foreach (var client in netManager.ConnectedClients)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteBool(true);
writer.WriteUInt32Packed(netObject.NetworkId);
writer.WriteUInt32Packed(netObject.OwnerClientId);
writer.WriteInt32Packed(netManager.NetworkConfig.NetworkPrefabIds[netObject.NetworkedPrefabName]);
writer.WriteBool(netObject.sceneObject == null ? true : netObject.sceneObject.Value);
writer.WriteSinglePacked(netObject.transform.position.x);
writer.WriteSinglePacked(netObject.transform.position.y);
writer.WriteSinglePacked(netObject.transform.position.z);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.z);
writer.WriteBool(payload != null);
netObject.WriteNetworkedVarData(stream, client.Key);
if (payload != null)
{
stream.CopyFrom(payload);
}
InternalMessageHandler.Send(client.Key, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream);
}
}
}
}
