Beispiel #1
0
        private void AuthRPC(string methodName, NetWorker socket, NetworkingPlayer player, bool runOnServer, string uniqueIdentifier, bool reliable, params object[] arguments)
        {
            int rpcId = GetStreamRPC(methodName, NetworkReceivers.All, arguments);

            if (socket is CrossPlatformUDP)
            {
                ((CrossPlatformUDP)socket).Write(uniqueIdentifier + methodName, player, rpcNetworkingStream, reliable);
            }
            else
            {
                socket.Write(player, rpcNetworkingStream);
            }

            if (socket.IsServer && runOnServer)
            {
                Unity.MainThreadManager.Run(() =>
                {
                    bool failedValidate = false;

                    foreach (IBRPCIntercept intercept in RPCs[rpcId].Value)
                    {
                        if (!intercept.ValidateRPC(RPCs[rpcId].Key))
                        {
                            failedValidate = true;
                            break;
                        }
                    }

                    if (!failedValidate)
                    {
                        RPCs[rpcId].Key.Invoke(this, arguments);
                    }
                });
            }
        }
Beispiel #2
0
        /// <summary>
        /// Call an Unreliable RPC method on a NetWorker(Socket) with receivers and arguments
        /// </summary>
        /// <param name="methodName">Method(Function) name to call</param>
        /// <param name="socket">The NetWorker(Socket) being used</param>
        /// <param name="receivers">Who shall receive the RPC</param>
        /// <param name="arguments">The RPC function parameters to be passed in</param>
        public void URPC(string methodName, NetWorker socket, NetworkReceivers receivers, params object[] arguments)
        {
            int rpcId = GetStreamRPC(methodName, receivers, arguments);

            // JM: offline fix
            if (NetworkingManager.IsOnline)
            {
                if (socket is CrossPlatformUDP)
                {
                    ((CrossPlatformUDP)socket).Write("BMS_INTERNAL_Rpc_" + methodName, rpcNetworkingStream, false);
                }
                else
                {
                    socket.Write(rpcNetworkingStream);
                }
            }

            // JM: added offline check and simular change that was in the reliable RPC
            if ((!NetworkingManager.IsOnline || socket.IsServer) && receivers != NetworkReceivers.Others && receivers != NetworkReceivers.OthersBuffered && receivers != NetworkReceivers.OthersProximity)
            {
                Unity.MainThreadManager.Run(() =>
                {
                    bool faildValidate = false;

                    foreach (IBRPCIntercept intercept in RPCs[rpcId].Value)
                    {
                        if (!intercept.ValidateRPC(RPCs[rpcId].Key))
                        {
                            faildValidate = true;
                            break;
                        }
                    }

                    if (faildValidate)
                    {
                        return;
                    }

                    List <object> args = new List <object>();
                    int argCount       = 0;
                    foreach (ParameterInfo info in RPCs[rpcId].Key.GetParameters())
                    {
                        if (info.ParameterType == typeof(MessageInfo))
                        {
                            args.Add(new MessageInfo(OwningNetWorker.Me.NetworkId, NetworkingManager.Instance.CurrentFrame));
                        }
                        else
                        {
                            args.Add(arguments[argCount++]);
                        }
                    }

                    CurrentRPCSender = OwningPlayer;
                    RPCs[rpcId].Key.Invoke(this, args.ToArray());
                    CurrentRPCSender = null;
                });
            }
        }