/// <summary> /// Send a spawn message. /// </summary> /// <param name="netIdentity">The TinyNetIdentity of the object to spawn.</param> /// <param name="targetPeer">If null, send to all connected peers.</param> public void SendSpawnMessage(TinyNetIdentity netIdentity, TinyNetConnection targetConn = null) { if (netIdentity.ServerOnly) { return; } TinyNetObjectSpawnMessage msg = new TinyNetObjectSpawnMessage(); msg.networkID = netIdentity.TinyInstanceID.NetworkID; msg.assetIndex = TinyNetGameManager.instance.GetAssetIdFromAssetGUID(netIdentity.assetGUID); msg.position = netIdentity.transform.position; msg.frameTick = ServerTick; // Include state of TinyNetObjects. s_recycleWriter.Reset(); netIdentity.TinySerialize(s_recycleWriter, true); if (s_recycleWriter.Length > 0) { msg.initialState = s_recycleWriter.CopyData(); } if (targetConn != null) { SendMessageByChannelToTargetConnection(msg, DeliveryMethod.ReliableOrdered, targetConn); } else { SendMessageByChannelToAllConnections(msg, DeliveryMethod.ReliableOrdered); } }
//============ Connections Methods ==================// /// <summary> /// Always call this from a TinyNetConnection ShowObjectToConnection, or you will have sync issues. /// </summary> /// <param name="tinyNetId">The tiny net identifier.</param> /// <param name="conn">The connection.</param> public void ShowForConnection(TinyNetIdentity tinyNetId, TinyNetConnection conn) { if (conn.isReady) { instance.SendSpawnMessage(tinyNetId, conn); } }
//============ TinyNetIdentity Functions ============// /// <summary> /// Applies the initial state of an object (it's <see cref="TinyNetSyncVar"/>). /// </summary> /// <param name="tinyNetId">The <see cref="TinyNetIdentity"/>r.</param> /// <param name="position">The position.</param> /// <param name="initialState">The initial state.</param> /// <param name="networkID">The network identifier.</param> /// <param name="newGameObject">The new <see cref="GameObject"/>.</param> void ApplyInitialState(TinyNetIdentity tinyNetId, Vector3 position, byte[] initialState, int networkID, GameObject newGameObject) { if (!tinyNetId.gameObject.activeSelf) { tinyNetId.gameObject.SetActive(true); } tinyNetId.transform.position = position; tinyNetId.OnNetworkCreate(); if (initialState != null && initialState.Length > 0) { var initialStateReader = new NetDataReader(initialState); tinyNetId.DeserializeAllTinyNetObjects(initialStateReader, true); } if (newGameObject == null) { return; } newGameObject.SetActive(true); tinyNetId.ReceiveNetworkID(networkID); AddTinyNetIdentityToList(tinyNetId); // If the object was spawned as part of the initial replication (s_TineNetObjectSpawnFinishedMessage.state == 0) it will have it's OnStartClient called by OnObjectSpawnFinished. if (_isSpawnFinished) { tinyNetId.OnStartClient(); } }
/// <summary> /// Always call this from a TinyNetConnection RemoveFromVisList, or you will have sync issues. /// </summary> /// <param name="tinyNetId">The tiny net identifier.</param> /// <param name="conn">The connection.</param> public void HideForConnection(TinyNetIdentity tinyNetId, TinyNetConnection conn) { TinyNetObjectHideMessage msg = new TinyNetObjectHideMessage(); msg.networkID = tinyNetId.TinyInstanceID.NetworkID; SendMessageByChannelToTargetConnection(msg, DeliveryMethod.ReliableOrdered, conn); }
/// <summary> /// Gets a <see cref="TinyNetIdentity"/> by it's network identifier. /// </summary> /// <param name="nId">The NetworkID.</param> /// <returns></returns> public static TinyNetIdentity GetTinyNetIdentityByNetworkID(int nId) { TinyNetIdentity reference = null; _localIdentityObjects.TryGetValue(nId, out reference); //return _localIdentityObjects.ContainsKey(nId) ? _localIdentityObjects[nId] : null; return(reference); }
/// <summary> /// Adds an object to the list of owned objects. /// </summary> /// <param name="obj">The <see cref="TinyNetIdentity"/> of the object to own.</param> public void AddOwnedObject(TinyNetIdentity obj) { if (_ownedObjectsId == null) { _ownedObjectsId = new HashSet <int>(); } _ownedObjectsId.Add(obj.NetworkID); }
/// <summary> /// Removes the owned object from the list. /// </summary> /// <param name="obj">The <see cref="TinyNetIdentity"/> of the object to remove.</param> public void RemoveOwnedObject(TinyNetIdentity obj) { if (_ownedObjectsId == null) { return; } _ownedObjectsId.Remove(obj.NetworkID); }
/// <summary> /// Called when a scene object is spawned and we are a Listen Server. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectSpawnSceneMessage"/>.</param> void OnLocalClientObjectSpawnScene(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectSpawnSceneMessage); TinyNetIdentity localObject = _localIdentityObjects[s_TinyNetObjectSpawnSceneMessage.networkID]; if (localObject != null) { localObject.OnSetLocalVisibility(true); } }
/// <summary> /// Called when a scene object is spawned and we are a Listen Server. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectSpawnSceneMessage"/>.</param> void OnLocalClientObjectSpawnScene(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectSpawnSceneMessage); TinyNetIdentity localObject = GetTinyNetIdentityByNetworkID(s_TinyNetObjectSpawnSceneMessage.networkID); if (localObject != null) { localObject.OnGiveLocalVisibility(); } }
/// <summary> /// Spawns the scene object. /// </summary> /// <param name="sceneId">The scene identifier.</param> /// <returns></returns> TinyNetIdentity SpawnSceneObject(int sceneId) { if (_sceneIdentityObjectsToSpawn.ContainsKey(sceneId)) { TinyNetIdentity foundId = _sceneIdentityObjectsToSpawn[sceneId]; _sceneIdentityObjectsToSpawn.Remove(sceneId); return(foundId); } return(null); }
/// <summary>Gets a <see cref="ITinyNetComponent"/> by it's network identifier.</summary> /// <param name="networkId">The network identifier.</param> /// <param name="localId">The local identifier on the TinyNetIdentity.</param> /// <returns></returns> public static ITinyNetComponent GetTinyNetComponentByNetworkID(int networkId, byte localId) { ITinyNetComponent reference = null; //return _localNetObjects.ContainsKey(nId) ? _localNetObjects[nId] : null; if (networkId >= 0) { TinyNetIdentity tinyNetRef = GetTinyNetIdentityByNetworkID(networkId); reference = tinyNetRef.GetComponentById(localId); } return(reference); }
static bool GetTinyNetIdentity(GameObject go, out TinyNetIdentity view) { view = go.GetComponent <TinyNetIdentity>(); if (view == null) { if (TinyNetLogLevel.logError) { TinyLogger.LogError("TinyBirdNet failure. GameObject doesn't have TinyNetIdentity."); } return(false); } return(true); }
/// <summary> /// Sends the RPC to all clients. /// </summary> /// <param name="stream">The stream.</param> /// <param name="rpcMethodIndex">Index of the RPC method.</param> /// <param name="iObj">The object.</param> public void SendRPCToAllClients(NetDataWriter stream, int rpcMethodIndex, ITinyNetComponent iObj) { //TODO: Pack rpc messages var msg = new TinyNetRPCMessage(); msg.networkID = iObj.TinyInstanceID.NetworkID; msg.componentID = iObj.TinyInstanceID.ComponentID; msg.rpcMethodIndex = rpcMethodIndex; msg.frameTick = ServerTick; msg.parameters = stream.Data; TinyNetIdentity tni = GetTinyNetIdentityByNetworkID(iObj.TinyInstanceID.NetworkID); SendMessageByChannelToAllObserversOf(tni, msg, DeliveryMethod.ReliableOrdered); }
/// <summary> /// Always call this to spawn an object to a client, or you will have sync issues. /// </summary> /// <param name="tni">The <see cref="TinyNetIdentity"/> of the object to spawn.</param> public void ShowObjectToConnection(TinyNetIdentity tni) { if (_observingNetObjects.Contains(tni)) { if (TinyNetLogLevel.logDev) { TinyLogger.Log("ShowObjectToConnection() called but object with networkdID: " + tni.NetworkID + " is already shown"); } return; } _observingNetObjects.Add(tni); // spawn tiny for this conn TinyNetServer.instance.ShowForConnection(tni, this); }
/// <summary> /// Called when an object is hidden and we are a Listen Server. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectHideMessage"/>.</param> void OnLocalClientObjectHide(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectHideMessage); if (TinyNetLogLevel.logDebug) { TinyLogger.Log("TinyNetClient::OnLocalObjectObjHide netId:" + s_TinyNetObjectHideMessage.networkID); } TinyNetIdentity localObject = GetTinyNetIdentityByNetworkID(s_TinyNetObjectHideMessage.networkID); if (localObject != null) { localObject.OnRemoveLocalVisibility(); } }
/// <summary> /// Called when we receive an Authorithy message from the server. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetClientAuthorityMessage"/>.</param> void OnClientAuthorityMessage(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetClientAuthorityMessage); if (TinyNetLogLevel.logDebug) { TinyLogger.Log("TinyNetClient::OnClientAuthority for connectionId=" + netMsg.tinyNetConn.ConnectId + " netId: " + s_TinyNetClientAuthorityMessage.networkID); } TinyNetIdentity tni = GetTinyNetIdentityByNetworkID(s_TinyNetClientAuthorityMessage.networkID); if (tni != null) { tni.HandleClientAuthority(s_TinyNetClientAuthorityMessage.authority); } }
/// <summary> /// Sends the message by a specific channel to all observers of a <see cref="TinyNetIdentity"/>. /// </summary> /// <param name="tni">The <see cref="TinyNetIdentity"/>.</param> /// <param name="msg">The message.</param> /// <param name="sendOptions">The send options.</param> public virtual void SendMessageByChannelToAllObserversOf(TinyNetIdentity tni, ITinyNetMessage msg, DeliveryMethod sendOptions) { recycleWriter.Reset(); recycleWriter.Put(msg.msgType); msg.Serialize(recycleWriter); for (int i = 0; i < tinyNetConns.Count; i++) { if (!tinyNetConns[i].IsObservingNetIdentity(tni)) { return; } tinyNetConns[i].Send(recycleWriter, sendOptions); } }
/// <summary> /// Calls TinyDeserialize in all Components that we received updates for. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetMsgType.StateUpdate"/> message.</param> void OnStateUpdateMessage(TinyNetMessageReader netMsg) { LastServerTick = netMsg.reader.GetUShort(); if (TinyNetLogLevel.logDev) { TinyLogger.Log("TinyNetClient::OnStateUpdateMessage frame: " + LastServerTick + " channel: " + netMsg.channelId); } while (netMsg.reader.AvailableBytes > 0) { int networkID = netMsg.reader.GetInt(); int rSize = netMsg.reader.GetInt(); _stateUpdateReader.Clear(); //Debug.Log("OnStateUpdate: RawDataSize: " + netMsg.reader.RawDataSize + ", Position: " + netMsg.reader.Position + ", rSize: " + rSize); _stateUpdateReader.SetSource(netMsg.reader.RawData, netMsg.reader.Position, rSize + netMsg.reader.Position); _stateUpdateReader.SetFrameTick(LastServerTick); //Debug.Log("OnStateUpdate: _stateUpdateReader " + _stateUpdateReader.RawDataSize + ", Position: " + _stateUpdateReader.Position); TinyNetIdentity localObject = GetTinyNetIdentityByNetworkID(networkID); if (localObject != null) { localObject.TinyDeserialize(_stateUpdateReader, false); } else { if (TinyNetLogLevel.logWarn) { TinyLogger.LogWarning("Did not find target for sync message for " + networkID); } } // We jump the reader position to the amount of data we read. //netMsg.reader.SetSource(netMsg.reader.RawData, netMsg.reader.Position + rSize, netMsg.reader.RawDataSize); netMsg.reader.SkipBytes(rSize); } foreach (TinyNetIdentity tinyNetId in LocalIdentityObjects.Values) { tinyNetId.OnStateUpdate(); } }
/// <summary> /// Called when an object is spawned and we are a Listen Server. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectSpawnMessage"/>.</param> void OnLocalClientObjectSpawn(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectSpawnMessage); TinyNetIdentity localObject = GetTinyNetIdentityByNetworkID(s_TinyNetObjectSpawnMessage.networkID); if (localObject != null) { localObject.OnStartClient(); localObject.OnGiveLocalVisibility(); } else { if (TinyNetLogLevel.logDebug) { TinyLogger.Log("TinyNetClient::OnLocalClientObjectSpawn called but object has never been spawned to client netId:" + s_TinyNetObjectSpawnMessage.networkID); } } }
/// <summary> /// Always call this to hide an object from a client, or you will have sync issues. /// </summary> /// <param name="tni">The <see cref="TinyNetIdentity"/> of the object to hide.</param> public void HideObjectToConnection(TinyNetIdentity tni, bool isDestroyed) { if (!_observingNetObjects.Contains(tni)) { if (TinyNetLogLevel.logDev) { TinyLogger.LogWarning("RemoveFromVisList() called but object with networkdID: " + tni.NetworkID + " is not shown"); } return; } _observingNetObjects.Remove(tni); if (!isDestroyed) { // hide tni for this conn TinyNetServer.instance.HideForConnection(tni, this); } }
//============ TinyNetIdentity Functions ============// /// <summary> /// Applies the initial state of an object (it's <see cref="TinyNetSyncVar"/>). /// </summary> /// <param name="tinyNetId">The <see cref="TinyNetIdentity"/>r.</param> /// <param name="position">The position.</param> /// <param name="initialState">The initial state.</param> /// <param name="networkID">The network identifier.</param> /// <param name="newGameObject">The new <see cref="GameObject"/>.</param> void ApplyInitialState(TinyNetIdentity tinyNetId, Vector3 position, byte[] initialState, int networkID, GameObject newGameObject, ushort frameTick) { if (!tinyNetId.gameObject.activeSelf) { tinyNetId.gameObject.SetActive(true); } tinyNetId.transform.position = position; tinyNetId.OnNetworkCreate(); if (newGameObject != null) { tinyNetId.ReceiveNetworkID(new TinyNetworkID(networkID)); } if (initialState != null && initialState.Length > 0) { _stateUpdateReader.Clear(); _stateUpdateReader.SetSource(initialState); _stateUpdateReader.SetFrameTick(frameTick); tinyNetId.TinyDeserialize(_stateUpdateReader, true); } // If this is null then this object already existed (already have a networkID and was registered in TinyNetScene), just apply the update to existing object if (newGameObject == null) { return; } newGameObject.SetActive(true); tinyNetId.ReceiveNetworkID(new TinyNetworkID(networkID)); AddTinyNetIdentityToList(tinyNetId); // If the object was spawned as part of the initial replication (s_TineNetObjectSpawnFinishedMessage.state == 0) it will have it's OnStartClient called by OnObjectSpawnFinished. if (_isSpawnFinished) { tinyNetId.OnStartClient(); } }
/// <summary> /// Destroys the object. /// </summary> /// <param name="tni">The <see cref="TinyNetIdentity"/> of the object.</param> /// <param name="destroyServerObject">if set to <c>true</c> destroy the object on server too.</param> public void DestroyObject(TinyNetIdentity tni, bool destroyServerObject) { if (TinyNetLogLevel.logDebug) { TinyLogger.Log("DestroyObject instance:" + tni.TinyInstanceID); } /*if (_localIdentityObjects.ContainsKey(tni.TinyInstanceID.NetworkID)) { * _localIdentityObjects.Remove(tni.TinyInstanceID.NetworkID); * }*/ RemoveTinyNetIdentityFromList(tni); if (tni.ConnectionToOwnerClient != null) { tni.ConnectionToOwnerClient.RemoveOwnedObject(tni); } TinyNetObjectDestroyMessage msg = new TinyNetObjectDestroyMessage(); msg.networkID = tni.TinyInstanceID.NetworkID; SendMessageByChannelToAllObserversOf(tni, msg, DeliveryMethod.ReliableOrdered); for (int i = 0; i < tinyNetConns.Count; i++) { tinyNetConns[i].HideObjectToConnection(tni, true); } /*if (TinyNetGameManager.instance.isListenServer) { * tni.OnNetworkDestroy(); * }*/ tni.OnNetworkDestroy(); // when unspawning, dont destroy the server's object if (destroyServerObject) { Object.Destroy(tni.gameObject); } tni.ReceiveNetworkID(new TinyNetworkID(-1)); }
/// <summary> /// Called when an object is destroyed. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectDestroyMessage"/>.</param> void OnObjectDestroy(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectDestroyMessage); if (TinyNetLogLevel.logDebug) { TinyLogger.Log("TinyNetClient::OnObjDestroy networkID:" + s_TinyNetObjectDestroyMessage.networkID); } TinyNetIdentity localObject = GetTinyNetIdentityByNetworkID(s_TinyNetObjectDestroyMessage.networkID); if (localObject != null) { RemoveTinyNetIdentityFromList(localObject); localObject.OnNetworkDestroy(); if (!TinyNetGameManager.instance.InvokeUnSpawnHandler(localObject.assetGUID, localObject.gameObject)) { // default handling if (localObject.sceneID == 0) { Object.Destroy(localObject.gameObject); } else { // scene object.. disable it in scene instead of destroying localObject.gameObject.SetActive(false); _sceneIdentityObjectsToSpawn[localObject.sceneID] = localObject; } } } else { if (TinyNetLogLevel.logDebug) { TinyLogger.LogWarning("Did not find target for destroy message for " + s_TinyNetObjectDestroyMessage.networkID); } } }
/// <summary> /// Called when a scene object is spawned. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectSpawnSceneMessage"/>.</param> void OnObjectSpawnScene(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectSpawnSceneMessage); if (TinyNetLogLevel.logDebug) { TinyLogger.Log("Client spawn scene handler instantiating [networkID: " + s_TinyNetObjectSpawnSceneMessage.networkID + " sceneId: " + s_TinyNetObjectSpawnSceneMessage.sceneId + " pos: " + s_TinyNetObjectSpawnSceneMessage.position); } TinyNetIdentity localTinyNetIdentity = GetTinyNetIdentityByNetworkID(s_TinyNetObjectSpawnSceneMessage.networkID); if (localTinyNetIdentity != null) { // this object already exists (was in the scene) ApplyInitialState(localTinyNetIdentity, s_TinyNetObjectSpawnSceneMessage.position, s_TinyNetObjectSpawnSceneMessage.initialState, s_TinyNetObjectSpawnSceneMessage.networkID, localTinyNetIdentity.gameObject, s_TinyNetObjectSpawnSceneMessage.frameTick); return; } TinyNetIdentity spawnedId = SpawnSceneObject(s_TinyNetObjectSpawnSceneMessage.sceneId); if (spawnedId == null) { if (TinyNetLogLevel.logError) { TinyLogger.LogError("Spawn scene object not found for " + s_TinyNetObjectSpawnSceneMessage.sceneId); } return; } if (TinyNetLogLevel.logDebug) { TinyLogger.Log("Client spawn for [networkID :" + s_TinyNetObjectSpawnSceneMessage.networkID + "] [sceneId: " + s_TinyNetObjectSpawnSceneMessage.sceneId + "] obj: " + spawnedId.gameObject.name); } ApplyInitialState(spawnedId, s_TinyNetObjectSpawnSceneMessage.position, s_TinyNetObjectSpawnSceneMessage.initialState, s_TinyNetObjectSpawnSceneMessage.networkID, spawnedId.gameObject, s_TinyNetObjectSpawnSceneMessage.frameTick); }
/// <summary> /// Removes the <see cref="TinyNetIdentity"/> from the list. /// </summary> /// <param name="netIdentity">The net identity.</param> public static void RemoveTinyNetIdentityFromList(TinyNetIdentity netIdentity) { _localIdentityObjects.Remove(netIdentity.NetworkID); }
/// <summary> /// Unspawn an object. /// </summary> /// <param name="obj">The <see cref="TinyNetIdentity"/> to unspawn.</param> public void UnSpawnObject(TinyNetIdentity tni) { DestroyObject(tni, false); }
/// <summary> /// Called when an object is spawned. /// </summary> /// <param name="netMsg">A wrapper for a <see cref="TinyNetObjectSpawnMessage"/>.</param> void OnObjectSpawn(TinyNetMessageReader netMsg) { netMsg.ReadMessage(s_TinyNetObjectSpawnMessage); if (s_TinyNetObjectSpawnMessage.assetIndex < 0 || s_TinyNetObjectSpawnMessage.assetIndex > int.MaxValue || s_TinyNetObjectSpawnMessage.assetIndex > TinyNetGameManager.instance.GetAmountOfRegisteredAssets()) { if (TinyNetLogLevel.logError) { TinyLogger.LogError("OnObjSpawn networkID: " + s_TinyNetObjectSpawnMessage.networkID + " has invalid asset Id"); } return; } if (TinyNetLogLevel.logDev) { TinyLogger.Log("Client spawn handler instantiating [networkID:" + s_TinyNetObjectSpawnMessage.networkID + " asset ID:" + s_TinyNetObjectSpawnMessage.assetIndex + " pos:" + s_TinyNetObjectSpawnMessage.position + "]"); } TinyNetIdentity localTinyNetIdentity = GetTinyNetIdentityByNetworkID(s_TinyNetObjectSpawnMessage.networkID); // Check if this object was already registered in the scene: if (localTinyNetIdentity != null) { // this object already exists (was in the scene), just apply the update to existing object. ApplyInitialState(localTinyNetIdentity, s_TinyNetObjectSpawnMessage.position, s_TinyNetObjectSpawnMessage.initialState, s_TinyNetObjectSpawnMessage.networkID, null, s_TinyNetObjectSpawnMessage.frameTick); return; } GameObject prefab; SpawnDelegate handler; prefab = TinyNetGameManager.instance.GetPrefabFromAssetId(s_TinyNetObjectSpawnMessage.assetIndex); // Check if the prefab is registered in the list of spawnable prefabs. if (prefab != null) { var obj = (GameObject)Object.Instantiate(prefab, s_TinyNetObjectSpawnMessage.position, Quaternion.identity); localTinyNetIdentity = obj.GetComponent <TinyNetIdentity>(); if (localTinyNetIdentity == null) { if (TinyNetLogLevel.logError) { TinyLogger.LogError("Client object spawned for " + s_TinyNetObjectSpawnMessage.assetIndex + " does not have a TinyNetidentity"); } return; } ApplyInitialState(localTinyNetIdentity, s_TinyNetObjectSpawnMessage.position, s_TinyNetObjectSpawnMessage.initialState, s_TinyNetObjectSpawnMessage.networkID, obj, s_TinyNetObjectSpawnMessage.frameTick); // If not, check if the prefab have a spawn handler registered. } else if (TinyNetGameManager.instance.GetSpawnHandler(s_TinyNetObjectSpawnMessage.assetIndex, out handler)) { GameObject obj = handler(s_TinyNetObjectSpawnMessage.position, s_TinyNetObjectSpawnMessage.assetIndex); if (obj == null) { if (TinyNetLogLevel.logWarn) { TinyLogger.LogWarning("Client spawn handler for " + s_TinyNetObjectSpawnMessage.assetIndex + " returned null"); } return; } localTinyNetIdentity = obj.GetComponent <TinyNetIdentity>(); if (localTinyNetIdentity == null) { if (TinyNetLogLevel.logError) { TinyLogger.LogError("Client object spawned for " + s_TinyNetObjectSpawnMessage.assetIndex + " does not have a network identity"); } return; } localTinyNetIdentity.SetDynamicAssetGUID(TinyNetGameManager.instance.GetAssetGUIDFromAssetId(s_TinyNetObjectSpawnMessage.assetIndex)); ApplyInitialState(localTinyNetIdentity, s_TinyNetObjectSpawnMessage.position, s_TinyNetObjectSpawnMessage.initialState, s_TinyNetObjectSpawnMessage.networkID, obj, s_TinyNetObjectSpawnMessage.frameTick); // If also not, we literally cannot spawn this object and you should feel bad. } else { if (TinyNetLogLevel.logError) { TinyLogger.LogError("Failed to spawn server object, assetId=" + s_TinyNetObjectSpawnMessage.assetIndex + " networkID=" + s_TinyNetObjectSpawnMessage.networkID); } } }
//============ Object Networking ====================// /// <summary> /// Adds the <see cref="TinyNetIdentity"/> to list. /// </summary> /// <param name="netIdentity">The net identity.</param> public static void AddTinyNetIdentityToList(TinyNetIdentity netIdentity) { _localIdentityObjects.Add(netIdentity.NetworkID, netIdentity); }
//============ Network Identity =====================// /// <summary> /// Determines whether this instance is observing the specified <see cref="TinyNetIdentity"/>. /// </summary> /// <param name="tni">The <see cref="TinyNetIdentity"/>.</param> /// <returns> /// <c>true</c> if is observing the specified <see cref="TinyNetIdentity"/>; otherwise, <c>false</c>. /// </returns> public bool IsObservingNetIdentity(TinyNetIdentity tni) { return(_observingNetObjects.Contains(tni)); }
/// <summary> /// Removes the <see cref="TinyNetIdentity"/> from the list. /// </summary> /// <param name="netIdentity">The net identity.</param> public static bool RemoveTinyNetIdentityFromList(TinyNetIdentity netIdentity) { return(_localIdentityObjects.Remove(netIdentity.TinyInstanceID.NetworkID)); }