Exemple #1
0
		/// <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.WriteString(config.protocalVersion);

					writer.WriteInt32Packed(config.receiveTickrate);
					writer.WriteInt32Packed(config.maxReceiveEventsPerTickRate);
					writer.WriteInt32Packed(config.eventTickrate);
					writer.WriteInt32Packed(config.clientConnectionBufferTimeout);
					writer.WriteInt32Packed(config.secondsHistory);
					writer.WriteBool(config.enableTimeResync);
					writer.WriteBool(config.ensureNetworkedVarLengthSafety);
					writer.WriteBits((byte)config.rpcHashSize, 3);
					writer.WriteBool(recycleNetworkIDs);
					writer.WriteSinglePacked(networkIDRecycleDelay);
					writer.WriteBool(enableNetworkedVar);
                    writer.WriteBool(clientSendSceneEvents);
                    writer.WriteBool(serverSendSceneEvents);
                    stream.PadStream();

					return Convert.ToBase64String(stream.ToArray());
				}
			}
		}
        /// <summary>
        /// Sends the named message
        /// </summary>
        /// <param name="name">The message name to send</param>
        /// <param name="clientIds">The clients to send to, sends to everyone if null</param>
        /// <param name="stream">The message stream containing the data</param>
        /// <param name="channel">The channel to send the data on</param>
        /// <param name="security">The security settings to apply to the message</param>
        public static void SendNamedMessage(string name, List <ulong> clientIds, Stream stream, string channel = null, SecuritySendFlags security = SecuritySendFlags.None)
        {
            ulong hash = NetworkedBehaviour.HashMethodName(name);

            using (PooledBitStream messageStream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(messageStream))
                {
                    writer.WriteUInt64Packed(hash);
                }

                messageStream.CopyFrom(stream);

                if (!NetworkingManager.Singleton.IsServer)
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                    {
                        NetworkLog.LogWarning("Can not send named messages to multiple users as a client");
                    }
                    return;
                }

                InternalMessageSender.Send(MLAPIConstants.MLAPI_NAMED_MESSAGE, string.IsNullOrEmpty(channel) ? "MLAPI_DEFAULT_MESSAGE" : channel, clientIds, messageStream, security, null);
            }
        }
Exemple #3
0
		/// <summary>
		/// Gets a SHA256 hash of parts of the NetworkingConfiguration instance
		/// </summary>
		/// <param name="cache"></param>
		/// <returns></returns>
		public ulong GetConfig(bool cache = true)
		{
			if (ConfigHash != null && cache)
				return ConfigHash.Value;

			using (PooledBitStream stream = PooledBitStream.Get())
			{
				using (PooledBitWriter writer = PooledBitWriter.Get(stream))
				{
					writer.WriteString(protocalVersion);

					writer.WriteBool(enableNetworkedVar);
					writer.WriteBool(ensureNetworkedVarLengthSafety);
					writer.WriteBits((byte)rpcHashSize, 3);
					stream.PadStream();

					if (cache)
					{
						ConfigHash = stream.ToArray().GetStableHash64();
						return ConfigHash.Value;
					}

					return stream.ToArray().GetStableHash64();
				}
			}
		}
Exemple #4
0
        /// <summary>
        /// Hides a object from a specific client
        /// </summary>
        /// <param name="clientId">The client to hide the object for</param>
        public void NetworkHide(ulong clientId)
        {
            if (!IsSpawned)
            {
                throw new SpawnStateException("Object is not spawned");
            }

            if (!NetworkingManager.Singleton.IsServer)
            {
                throw new NotServerException("Only server can change visibility");
            }

            if (observers.Contains(clientId) && clientId != NetworkingManager.Singleton.ServerClientId)
            {
                // Send destroy call
                observers.Remove(clientId);

                using (PooledBitStream stream = PooledBitStream.Get())
                {
                    using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                    {
                        writer.WriteUInt64Packed(NetworkId);

                        InternalMessageSender.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
                    }
                }
            }
        }
        private void OnLog(string condition, string stackTrace, LogType logType)
        {
            //DO NOT CALL Debug.Log in this function or it will cause an infinite loop!
            //Wait until this network is ready to log.
            if (!sendLogEvents || !networkManager.isRunning || (!networkManager.isServer && !networkManager.isConnected))
            {
                return;
            }

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteString(condition);
                    writer.WriteBool(includeStacktrace);
                    if (includeStacktrace)
                    {
                        writer.WriteString(stackTrace);
                    }
                    writer.WriteByte((byte)logType);
                    if (networkManager.isServer)
                    {
                        //Send to all clients that are expecting it.
                        MessageSender.SendToSpecific(m_ClientsReceivingLogEvents, networkLogMessageType, "NETWORK_INTERNAL", stream);
                    }
                    else
                    {
                        //Send to server
                        MessageSender.Send(networkManager.serverID, networkLogMessageType, networkManager.networkInternalChannel, stream);
                    }
                }
            }
        }
Exemple #6
0
    public void Write(Stream stream)
    {
        using (PooledBitWriter writer = PooledBitWriter.Get(stream))
        {
            writer.WriteInt32Packed(TeamID);

            writer.WriteBool(isRightHanded);
            writer.WriteBool(isMoving);
            writer.WriteBool(isSprinting);
            writer.WriteBool(isDribbling);
            writer.WriteBool(isScreening);
            writer.WriteBool(isHardScreening);
            writer.WriteBool(isShooting);
            writer.WriteBool(isHelping);

            writer.WriteBool(isMovementFrozen);
            writer.WriteBool(isBallInLeftHand);
            writer.WriteBool(isCtrlDown);
            writer.WriteBool(isAltDown);
            writer.WriteBool(isDribUp);
            writer.WriteBool(isDribDown);
            writer.WriteBool(isDribLeft);
            writer.WriteBool(isDribRight);

            writer.WriteBool(isAI);

            writer.WriteVector3Packed(m_target);
        }
    }
Exemple #7
0
    // this happens after approval (96% sure :p)
    private void ML_OnClientConnected(ulong _clientId)
    {
        if (!NetworkingManager.Singleton.IsHost && !NetworkingManager.Singleton.IsServer)
        {
            return;
        }

        Debug.Log("Client " + _clientId + " connected");

        NetworkedClient client = NetworkingManager.Singleton.ConnectedClients[_clientId];
        Player          player = client.GetPlayer();



        player.ClientId.Value = _clientId;

        player.Name.Value = connectionDataCache[_clientId].playerName;

        connectionDataCache.Remove(_clientId);

        using (PooledBitStream stream = PooledBitStream.Get())
        {
            using (PooledBitWriter w = PooledBitWriter.Get(stream))
            {
                w.WriteUInt64(player.NetworkedObject.NetworkId);
                CustomMessagingManager.SendNamedMessage("ClientConnected", AllClientIDs(), stream);
            }
        }
    }
Exemple #8
0
        /// <summary>
        /// Spawns a object from the pool at a given position and rotation. Can only be called from server.
        /// </summary>
        /// <param name="poolName">The name of the pool</param>
        /// <param name="position">The position to spawn the object at</param>
        /// <param name="rotation">The rotation to spawn the object at</param>
        /// <returns></returns>
        public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)
        {
            if (!NetworkingManager.singleton.isServer)
            {
                if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
                {
                    LogHelper.LogWarning("Object spawning can only occur on server");
                }
                return(null);
            }
            NetworkedObject netObject = Pools[PoolNamesToIndexes[poolName]].SpawnObject(position, rotation);

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteUInt32Packed(netObject.NetworkId);

                    writer.WriteSinglePacked(position.x);
                    writer.WriteSinglePacked(position.y);
                    writer.WriteSinglePacked(position.z);

                    writer.WriteSinglePacked(rotation.eulerAngles.x);
                    writer.WriteSinglePacked(rotation.eulerAngles.y);
                    writer.WriteSinglePacked(rotation.eulerAngles.z);

                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream);
                }
            }
            return(netObject);
        }
        /// <inheritdoc />
        public void WriteDelta(Stream stream)
        {
            using (PooledBitWriter writer = PooledBitWriter.Get(stream))
            {
                writer.WriteUInt16Packed((ushort)dirtyEvents.Count);
                for (int i = 0; i < dirtyEvents.Count; i++)
                {
                    writer.WriteBits((byte)dirtyEvents[i].eventType, 2);

                    switch (dirtyEvents[i].eventType)
                    {
                    case NetworkedSetEvent <T> .EventType.Add:
                    {
                        writer.WriteObjectPacked(dirtyEvents[i].value);         //BOX
                    }
                    break;

                    case NetworkedSetEvent <T> .EventType.Remove:
                    {
                        writer.WriteObjectPacked(dirtyEvents[i].value);         //BOX
                    }
                    break;

                    case NetworkedSetEvent <T> .EventType.Clear:
                    {
                        //Nothing has to be written
                    }
                    break;
                    }
                }
            }
        }
        internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, bool skipQueue = false)
        {
            if (NetworkingManager.singleton.isServer && clientId == NetworkingManager.singleton.ServerClientId)
            {
                return;
            }
            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteByte(messageType);
                    stream.CopyFrom(messageStream);

                    NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
                    byte error;
                    if (skipQueue)
                    {
                        netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(clientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], true, out error);
                    }
                    else
                    {
                        netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(clientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], false, out error);
                    }
                    NetworkProfiler.EndEvent();
                }
            }
        }
        internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream)
        {
            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteByte(messageType);
                    stream.CopyFrom(messageStream);

                    NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
                    for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)
                    {
                        if (netManager.ConnectedClientsList[i].ClientId == clientIdToIgnore ||
                            (NetworkingManager.singleton.isServer && netManager.ConnectedClientsList[i].ClientId == NetworkingManager.singleton.ServerClientId))
                        {
                            continue;
                        }

                        byte error;
                        netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(netManager.ConnectedClientsList[i].ClientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], false, out error);
                    }
                    NetworkProfiler.EndEvent();
                }
            }
        }
Exemple #12
0
        private static void LogServer(string message, LogType logType)
        {
            // Get the sender of the local log
            ulong localId = NetworkingManager.Singleton != null ? NetworkingManager.Singleton.LocalClientId : 0;

            switch (logType)
            {
            case LogType.Info:
                LogInfoServerLocal(message, localId);
                break;

            case LogType.Warning:
                LogWarningServerLocal(message, localId);
                break;

            case LogType.Error:
                LogErrorServerLocal(message, localId);
                break;
            }

            if (NetworkingManager.Singleton != null && !NetworkingManager.Singleton.IsServer && NetworkingManager.Singleton.NetworkConfig.EnableNetworkLogs)
            {
                using (PooledBitStream stream = PooledBitStream.Get())
                {
                    using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                    {
                        writer.WriteByte((byte)logType);

                        writer.WriteStringPacked(message);

                        InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_SERVER_LOG, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
                    }
                }
            }
        }
 private void OnLeftSpawnButtonPressed()
 {
     if (leftNetworkSquare.isNetworkSpawned)
     {
         leftNetworkSquare.UnspawnOnNetwork();
     }
     else
     {
         if (m_NetworkManager.isServer)
         {
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                 {
                     writer.WriteSinglePacked(m_LeftObjectPositioner.rect.center.x);
                     writer.WriteSinglePacked(m_LeftObjectPositioner.rect.center.y);
                 }
                 leftNetworkSquare.SpawnOnNetwork(stream);
             }
         }
         else
         {
             leftNetworkSquare.SpawnOnNetwork();
         }
     }
 }
Exemple #14
0
        internal static void RemoveOwnership(NetworkedObject netObject)
        {
            if (!NetworkingManager.Singleton.IsServer)
            {
                throw new NotServerException("Only the server can change ownership");
            }

            if (!netObject.IsSpawned)
            {
                throw new SpawnStateException("Object is not spawned");
            }

            for (int i = NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
            {
                if (NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i] == netObject)
                {
                    NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.RemoveAt(i);
                }
            }

            netObject._ownerClientId = null;

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteUInt64Packed(netObject.NetworkId);
                    writer.WriteUInt64Packed(netObject.OwnerClientId);

                    InternalMessageSender.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, netObject);
                }
            }
        }
Exemple #15
0
        internal static void ChangeOwnership(uint netId, uint clientId)
        {
            if (!netManager.isServer)
            {
                if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
                {
                    LogHelper.LogWarning("You can only change ownership from Server");
                }
                return;
            }
            NetworkedObject netObject = SpawnManager.SpawnedObjects[netId];

            for (int i = NetworkingManager.singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
            {
                if (NetworkingManager.singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i].NetworkId == netId)
                {
                    NetworkingManager.singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.RemoveAt(i);
                }
            }
            NetworkingManager.singleton.ConnectedClients[clientId].OwnedObjects.Add(netObject);
            netObject.OwnerClientId = clientId;

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteUInt32Packed(netId);
                    writer.WriteUInt32Packed(clientId);

                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
                }
            }
        }
Exemple #16
0
    public void WriteDelta(Stream stream) => WriteField(stream); // Based on default NetworkedVar implementation. This class doesnt need this

    /// <inheritdoc />
    public void WriteField(Stream stream)
    {
        using (PooledBitWriter writer = PooledBitWriter.Get(stream))
        {
            writer.WriteObjectPacked(InternalValue); //BOX
        }
    }
        internal static BitStream WrapMessage(byte messageType, ulong clientID, BitStream messageBody, SecuritySendFlags flags)
        {
            try
            {
                bool encrypted     = ((flags & SecuritySendFlags.Encrypted) == SecuritySendFlags.Encrypted) && false;             //NetworkManager.Get().NetworkConfig.EnableEncryption;
                bool authenticated = (flags & SecuritySendFlags.Authenticated) == SecuritySendFlags.Authenticated && false;       //NetworkManager.Get().NetworkConfig.EnableEncryption;

                PooledBitStream outStream = PooledBitStream.Get();

                using (PooledBitWriter outWriter = PooledBitWriter.Get(outStream))
                {
                    outWriter.WriteBit(encrypted);
                    outWriter.WriteBit(authenticated);
                    outWriter.WriteBits(messageType, 6);
                    outStream.Write(messageBody.GetBuffer(), 0, (int)messageBody.Length);
                }

                return(outStream);
            }
            catch (Exception e)
            {
                Debug.LogError("Error while wrapping headers");
                Debug.LogError(e.ToString());

                return(null);
            }
        }
        // Ran on server
        internal static void HandleHailResponse(ulong clientId, Stream stream)
        {
            if (!NetworkingManager.Singleton.PendingClients.ContainsKey(clientId) || NetworkingManager.Singleton.PendingClients[clientId].ConnectionState != PendingClient.State.PendingHail)
            {
                return;
            }
            if (!NetworkingManager.Singleton.NetworkConfig.EnableEncryption)
            {
                return;
            }

            using (PooledBitReader reader = PooledBitReader.Get(stream))
            {
                if (NetworkingManager.Singleton.PendingClients[clientId].KeyExchange != null)
                {
                    byte[] diffieHellmanPublic = reader.ReadByteArray();
                    NetworkingManager.Singleton.PendingClients[clientId].AesKey = NetworkingManager.Singleton.PendingClients[clientId].KeyExchange.GetSharedSecret(diffieHellmanPublic);
                }
            }

            NetworkingManager.Singleton.PendingClients[clientId].ConnectionState = PendingClient.State.PendingConnection;
            NetworkingManager.Singleton.PendingClients[clientId].KeyExchange     = null; // Give to GC

            // Send greetings, they have passed all the handshakes
            using (PooledBitStream outStream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(outStream))
                {
                    writer.WriteInt64Packed(DateTime.Now.Ticks); // This serves no purpose.
                }

                InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_GREETINGS, "MLAPI_INTERNAL", outStream, SecuritySendFlags.None, null);
            }
        }
Exemple #19
0
        /// <summary>
        /// Hides a object from a specific client
        /// </summary>
        /// <param name="clientId">The client to hide the object for</param>
        public void NetworkHide(ulong clientId)
        {
            if (!NetworkingManager.Singleton.IsServer)
            {
                if (LogHelper.CurrentLogLevel <= LogLevel.Error)
                {
                    LogHelper.LogError("Can only call NetworkHide on the server");
                }
                return;
            }

            if (observers.Contains(clientId) && clientId != NetworkingManager.Singleton.ServerClientId)
            {
                // Send destroy call
                observers.Remove(clientId);

                using (PooledBitStream stream = PooledBitStream.Get())
                {
                    using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                    {
                        writer.WriteUInt64Packed(NetworkId);

                        InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
                    }
                }
            }
        }
Exemple #20
0
        public void InvokeServerRPC(RPCDelegate method, Stream messageStream, byte channel = NetworkTransport.DEFAULT_CHANNEL)
        {
            if (!isClient)
            {
                //We are only a server and not a client
                Debug.LogError("Tried to invoke a ServerRPC without being a client. Only a client can invoke a server RPC.", this);
                return;
            }

            ulong hash = HashMethod(method.Method);

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteUInt64Packed(networkID);
                    writer.WriteUInt64Packed(hash);

                    stream.CopyFrom(messageStream);

                    if (isHost)
                    {
                        messageStream.Position = 0;
                        //Invoke local
                        InvokeLocalServerRPC(hash, networkManager.clientID, stream);
                    }
                    else
                    {
                        MessageSender.Send(networkManager.serverID, m_NetworkBehaviourManager.serverRPCMessageType, channel, stream);
                    }
                }
            }
        }
Exemple #21
0
    //private void FixedUpdate()
    //{

    //}

    private void Fire()
    {
        Vector3 firePosition  = m_cameraFOV.transform.position;
        Vector3 fireDirection = m_cameraFOV.transform.forward;

        // Do server side hit detection only when there is a hit on client side. Just to save some server performance
        bool shouldVerifyHitOnServer = true;

        if (IVGameManager.Instance.m_useHitScan)
        {
            shouldVerifyHitOnServer = FireHitScan(firePosition, fireDirection);
        }
        else
        {
            shouldVerifyHitOnServer = InstantiateBullet(firePosition, fireDirection); // Instantiate bullet immediately on the client who is firing
        }
        using (PooledBitStream stream = PooledBitStream.Get())
        {
            using (PooledBitWriter writer = PooledBitWriter.Get(stream))
            {
                writer.WriteBool(shouldVerifyHitOnServer);
                writer.WriteVector3Packed(firePosition);
                writer.WriteVector3Packed(fireDirection);

                InvokeServerRpcPerformance(FireOnServer, stream);
            }
        }
    }
        internal static void OnFirstSceneSwitchSync(uint sceneIndex, Guid switchSceneGuid)
        {
            if (!sceneIndexToString.ContainsKey(sceneIndex) || !registeredSceneNames.Contains(sceneIndexToString[sceneIndex]))
            {
                if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
                {
                    LogHelper.LogWarning("Server requested a scene switch to a non registered scene");
                }
                return;
            }
            else if (SceneManager.GetActiveScene().name == sceneIndexToString[sceneIndex])
            {
                return; //This scene is already loaded. This usually happends at first load
            }

            lastScene = SceneManager.GetActiveScene();
            string sceneName = sceneIndexToString[sceneIndex];

            nextScene = SceneManager.GetSceneByName(sceneName);
            CurrentActiveSceneIndex = sceneNameToIndex[sceneName];

            SceneManager.LoadScene(sceneName);

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteByteArray(switchSceneGuid.ToByteArray());
                    InternalMessageHandler.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
                }
            }

            isSwitching = false;
        }
Exemple #23
0
        internal void SendClientRPCPerformance(ulong hash, uint clientId, Stream messageStream, string channel, SecuritySendFlags security)
        {
            if (!IsServer && IsRunning)
            {
                //We are NOT a server.
                if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
                {
                    LogHelper.LogWarning("Only clients and host can invoke ClientRPC");
                }
                return;
            }

            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteUInt32Packed(NetworkId);
                    writer.WriteUInt16Packed(NetworkedObject.GetOrderIndex(this));
                    writer.WriteUInt64Packed(hash);

                    stream.CopyFrom(messageStream);

                    if (IsHost && clientId == NetworkingManager.Singleton.LocalClientId)
                    {
                        messageStream.Position = 0;
                        InvokeClientRPCLocal(hash, NetworkingManager.Singleton.LocalClientId, messageStream);
                    }
                    else
                    {
                        InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CLIENT_RPC, string.IsNullOrEmpty(channel) ? "MLAPI_DEFAULT_MESSAGE" : channel, stream, security);
                    }
                }
            }
        }
Exemple #24
0
        internal static void HandleClientRPCRequest(ulong clientId, Stream stream, string channelName, SecuritySendFlags security)
        {
            using (PooledBitReader reader = PooledBitReader.Get(stream))
            {
                ulong  networkId   = reader.ReadUInt64Packed();
                ushort behaviourId = reader.ReadUInt16Packed();
                ulong  hash        = reader.ReadUInt64Packed();
                ulong  responseId  = reader.ReadUInt64Packed();

                if (SpawnManager.SpawnedObjects.ContainsKey(networkId))
                {
                    NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(behaviourId);
                    if (behaviour != null)
                    {
                        object result = behaviour.OnRemoteClientRPC(hash, clientId, stream);

                        using (PooledBitStream responseStream = PooledBitStream.Get())
                        {
                            using (PooledBitWriter responseWriter = PooledBitWriter.Get(responseStream))
                            {
                                responseWriter.WriteUInt64Packed(responseId);
                                responseWriter.WriteObjectPacked(result);
                            }

                            InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_CLIENT_RPC_RESPONSE, channelName, responseStream, security, null);
                        }
                    }
                }
            }
        }
Exemple #25
0
    private void OnTriggerEnter2D(Collider2D col)
    {
        switch (col.name)
        {
        case "LeftWall":
            right++;
            break;

        case "RightWall":
            left++;
            break;
        }

        using (PooledBitStream stream = PooledBitStream.Get())
        {
            using (PooledBitWriter writer = PooledBitWriter.Get(stream))
            {
                writer.WriteInt32(left);
                writer.WriteInt32(right);
                InvokeClientRpcOnEveryonePerformance(WinRPC, stream);
            }
        }

        Spawn();
    }
Exemple #26
0
        internal static void SendSpawnCallForObject(ulong clientId, NetworkedObject netObject, Stream payload)
        {
            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    writer.WriteBool(netObject.IsPlayerObject);
                    writer.WriteUInt64Packed(netObject.NetworkId);
                    writer.WriteUInt64Packed(netObject.OwnerClientId);

                    if (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);
                        }
                    }

                    writer.WriteBool(netObject.DestroyWithScene);

                    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);
                    }

                    if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
                    {
                        netObject.WriteNetworkedVarData(stream, clientId);
                    }

                    if (payload != null)
                    {
                        stream.CopyFrom(payload);
                    }
                }

                InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
            }
        }
Exemple #27
0
        void InvokeApplyTransform(ulong clientId, Vector3 position, Quaternion rotation, string channelName)
        {
            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    if (TransformTypeToSync == TransformType.Transform2D)
                    {
                        if (SyncPosition && SyncRotation)
                        {
                            writer.WriteVector2Packed(position);
                            writer.WriteSinglePacked(rotation.eulerAngles.z);
                        }
                        else if (SyncPosition)
                        {
                            writer.WriteVector2Packed(position);
                        }
                        else if (SyncRotation)
                        {
                            writer.WriteSinglePacked(rotation.eulerAngles.z);
                        }

                        InvokeClientRpcOnClientPerformance("ApplyTransform2D", clientId, stream, channelName, Security.SecuritySendFlags.None);
                    }
                    else if (TransformTypeToSync == TransformType.Transform3D)
                    {
                        if (SyncPosition && SyncRotation)
                        {
                            writer.WriteVector3Packed(position);
                            if (FullRotation)
                            {
                                writer.WriteVector3Packed(rotation.eulerAngles);
                            }
                            else
                            {
                                writer.WriteSingle(rotation.eulerAngles.y);
                            }
                        }
                        else if (SyncPosition)
                        {
                            writer.WriteVector3Packed(position);
                        }
                        else if (SyncRotation)
                        {
                            if (FullRotation)
                            {
                                writer.WriteVector3Packed(rotation.eulerAngles);
                            }
                            else
                            {
                                writer.WriteSingle(rotation.eulerAngles.y);
                            }
                        }

                        InvokeClientRpcOnClientPerformance("ApplyTransform", clientId, stream, channelName, Security.SecuritySendFlags.None);
                    }
                }
            }
        }
Exemple #28
0
 public void Write(Stream stream)
 {
     using (PooledBitWriter writer = PooledBitWriter.Get(stream))
     {
         writer.WriteInt32Packed(points);
         writer.WriteInt32Packed(fouls);
     }
 }
Exemple #29
0
 public void Write(Stream stream)
 {
     using (var writer = PooledBitWriter.Get(stream))
     {
         writer.WriteInt32Packed(playerId);
         writer.WriteVector2Packed(motion);
     }
 }
Exemple #30
0
 /// <inheritdoc />
 public void WriteField(Stream stream)
 {
     using (PooledBitWriter writer = PooledBitWriter.Get(stream))
     {
         writer.WriteUInt64Packed(InternalValue.clientID); //BOX
         writer.WriteUInt64Packed(InternalValue.networkID);
     }
 }