private EP2PSend NetworkDeliveryToEP2PSend(NetworkDelivery type)
        {
            EP2PSend options = EP2PSend.k_EP2PSendReliableWithBuffering;

            switch (type)
            {
            case NetworkDelivery.Unreliable:
                options = EP2PSend.k_EP2PSendUnreliable;
                break;

            case NetworkDelivery.UnreliableSequenced:
                options = EP2PSend.k_EP2PSendUnreliable;
                break;

            case NetworkDelivery.Reliable:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;

            case NetworkDelivery.ReliableSequenced:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;

            case NetworkDelivery.ReliableFragmentedSequenced:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;

            default:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;
            }

            return(options);
        }
        private int AddChannel(ChannelType type)
        {
            EP2PSend options = EP2PSend.k_EP2PSendReliableWithBuffering;

            switch (type)
            {
            case ChannelType.Unreliable:
                options = EP2PSend.k_EP2PSendUnreliable;
                break;

            case ChannelType.UnreliableSequenced:
                options = EP2PSend.k_EP2PSendUnreliable;
                break;

            case ChannelType.Reliable:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;

            case ChannelType.ReliableSequenced:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;

            case ChannelType.ReliableFragmentedSequenced:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;

            default:
                options = EP2PSend.k_EP2PSendReliableWithBuffering;
                break;
            }
            channelSendTypes.Add(channelCounter, options);
            channelCounter++;
            return(channelCounter - 1);
        }
        public override int GetMaxPacketSize(int channelId)
        {
            if (channelId >= channels.Length)
            {
                channelId = 0;
            }
            EP2PSend sendMethod = channels[channelId];

            switch (sendMethod)
            {
            case EP2PSend.k_EP2PSendUnreliable:
                return(1200);    //UDP like - MTU size.

            case EP2PSend.k_EP2PSendUnreliableNoDelay:
                return(1200);    //UDP like - MTU size.

            case EP2PSend.k_EP2PSendReliable:
                return(1048576);    //Reliable message send. Can send up to 1MB of data in a single message.

            case EP2PSend.k_EP2PSendReliableWithBuffering:
                return(1048576);    //Reliable message send. Can send up to 1MB of data in a single message.

            default:
                return(1200);    //UDP like - MTU size.
            }
        }
    private byte[] getByteArrayFromMessage(Message message, EP2PSend packetType, out uint length)
    {
        packetSingle.message  = message;
        packetSingle.sendType = packetType;
        MemoryStream memoryStream = new MemoryStream();

        binaryFormatter.Serialize(memoryStream, packetSingle);
        length = (uint)memoryStream.Length;

        ulong count = 0;

        if (Multiplayer._instance.displayPing)
        {
            if (messageCounterTypes.ContainsKey(message.type))
            {
                count  = messageCounterTypes[message.type];
                count += length;
                messageCounterTypes[message.type] = count;
                messageCounter += length;
            }
            else
            {
                messageCounterTypes.Add(message.type, length);
                messageCounter += length;
            }
        }

        return(memoryStream.ToArray());
    }
 public OutgoingNetworkPacketContainer(CSteamID receiver, object message, EP2PSend packetType, OutgoingReceivers outgoingReceivers)
 {
     this.outgoingReceivers = outgoingReceivers;
     SteamId    = receiver;
     Message    = message;
     PacketType = packetType;
 }
示例#6
0
    public override bool TransportSend(byte[] bytes, int numBytes, int channelId, out byte error)
    {
        if (steamId.m_SteamID == SteamUser.GetSteamID().m_SteamID)
        {
            // sending to self. short circuit
            TransportReceive(bytes, numBytes, channelId);
            error = 0;
            return(true);
        }

        EP2PSend eP2PSendType = EP2PSend.k_EP2PSendReliable;

        QosType qos = SteamNetworkManager.hostTopology.DefaultConfig.Channels[channelId].QOS;

        if (qos == QosType.Unreliable || qos == QosType.UnreliableFragmented || qos == QosType.UnreliableSequenced)
        {
            eP2PSendType = EP2PSend.k_EP2PSendUnreliable;
        }

        // Send packet to peer through Steam
        if (SteamNetworking.SendP2PPacket(steamId, bytes, (uint)numBytes, eP2PSendType, channelId))
        {
            error = 0;
            return(true);
        }
        else
        {
            error = 1;
            return(false);
        }
    }
    public void SendPacketAsHostToAllClients(Packet existingPacket, EP2PSend packetType)
    {
        OutgoingNetworkPacketContainer packet = new OutgoingNetworkPacketContainer(existingPacket, packetType);

        messageQueue.Enqueue(packet);
        waitHandle.Set();
    }
        public override void Send(ulong clientId, ArraySegment <byte> data, string channelName)
        {
            if (!channelNameToId.ContainsKey(channelName))
            {
                if (LogHelper.CurrentLogLevel <= LogLevel.Error)
                {
                    LogHelper.LogError("SteamP2PTransport - Can't Send to client, channel with channelName: " + channelName + " is not present");
                }
                return;
            }

            int      channelId = channelNameToId[channelName];
            EP2PSend sendType  = channelSendTypes[channelId];

            if (clientId == ServerClientId)
            {
                SteamNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, channelId);
            }
            else
            {
                if (connectedUsers.ContainsKey(clientId))
                {
                    SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, channelId);
                }
                else
                {
                    if (LogHelper.CurrentLogLevel <= LogLevel.Error)
                    {
                        LogHelper.LogError("SteamP2PTransport - Can't Send to client, client not connected, clientId: " + clientId);
                    }
                }
            }
        }
        public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
        {
            EP2PSend sendType = NetworkDeliveryToEP2PSend(delivery);

            if (clientId == ServerClientId)
            {
#if UNITY_SERVER
                SteamGameServerNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#else
                SteamNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#endif
            }
            else
            {
                if (connectedUsers.ContainsKey(clientId))
                {
#if UNITY_SERVER
                    SteamGameServerNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#else
                    SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#endif
                }
                else
                {
                    if (NetworkManager.Singleton.LogLevel <= LogLevel.Error)
                    {
                        NetworkLog.LogErrorServer(nameof(SteamNetworkingTransport) + " - Can't Send to client, client not connected, clientId: " + clientId);
                    }
                }
            }
        }
示例#10
0
        public override void Send(ulong clientId, ArraySegment <byte> data, string channelName)
        {
            if (!channelNameToId.ContainsKey(channelName))
            {
                if (NetworkingManager.Singleton.LogLevel <= LogLevel.Error)
                {
                    UnityEngine.Debug.Log("SteamP2PTransport - Can't Send to client, channel with channelName: " + channelName + " is not present");
                }
                return;
            }

            int      channelId = channelNameToId[channelName];
            EP2PSend sendType  = channelSendTypes[channelId];

            bool test = true;

            if (clientId == ServerClientId && !test)
            {
                SteamNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, channelId);
            }
            else
            {
                if (connectedUsers.ContainsKey(clientId))
                {
                    SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, channelId);
                }
                else
                {
                    if (NetworkingManager.Singleton.LogLevel <= LogLevel.Error)
                    {
                        UnityEngine.Debug.Log("SteamP2PTransport - Can't Send to client, client not connected, clientId: " + clientId);
                    }
                }
            }
        }
示例#11
0
        public void SendEntityData <T>(short packetId, T data, Entity sender, EP2PSend m = EP2PSend.k_EP2PSendReliable,
                                       bool sendToHost = false) where T : new()
        {
            var msg = new byte[1024];
            var pos = 0;

            msg = msg.Write(ref pos, packetId);
            msg = msg.Write(ref pos, sender.World.GetID());
            msg = msg.Write(ref pos, sender.Id);
            msg = msg.Write(ref pos, data.GetType().Name.ToSnakeCase());
            //var b = TypeHelper.WriteProperties(data);
            //msg = msg.Append(pos, b);
            //pos += b.Length;
            if (sendToHost)
            {
                SteamNetworking.SendP2PPacket(Host, msg, (uint)msg.Length, m);
            }
            else
            {
                foreach (var steamUser in RemoteUsers)
                {
                    if (steamUser != User)
                    {
                        SteamNetworking.SendP2PPacket(steamUser, msg, (uint)msg.Length, m);
                    }
                }
            }
        }
示例#12
0
 void SendPacket(CSteamID id, byte[] msg, uint size, EP2PSend reliability = EP2PSend.k_EP2PSendReliable)
 {
     if (!SteamNetworking.SendP2PPacket(id, msg, size, reliability))
     {
         Debug.LogAssertion("Failed to send Steam packet!");
     }
 }
示例#13
0
            public void SendPacket(DataPacket packet, CSteamID user, EP2PSend sendType = EP2PSend.k_EP2PSendUnreliableNoDelay)
            {
                if (DEBUG)
                {
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < packet.data.Length; i++)
                    {
                        sb.Append(packet.data[i] + "|");
                    }
                    //if (this.channelIndex != 2)
                    //    Log("Sending packet to player " + SteamFriends.GetFriendPersonaName(user) + " with data " + sb.ToString() + " in channel " + channelName);
                    //Log(Environment.StackTrace);
                }

                if (user.m_SteamID == NetworkGameManager.playerID)
                {
                    //Process packet immediately if we sent it to ourself.
                    ProcessPacket(packet);
                }
                else
                {
                    //Send it off to another player
                    SteamNetworking.SendP2PPacket(user, packet.data, (uint)packet.data.Length, sendType, channelIndex);
                }
            }
    public void SendPacketToSpecificPlayer(CSteamID receiver, Packet existingPacket, EP2PSend packetType)
    {
        OutgoingNetworkPacketContainer packet = new OutgoingNetworkPacketContainer(receiver, existingPacket, packetType, OutgoingNetworkPacketContainer.OutgoingReceivers.ToSinglePeer);

        messageQueue.Enqueue(packet);
        waitHandle.Set();
    }
示例#15
0
        protected override void SendImpl(int connectionId, byte[] buffer, int count,
                                         NetworkReliablity reliability)
        {
            ValidateSteamInitalized();
            EP2PSend ep2p = reliability == NetworkReliablity.Reliable ? EP2PSend.k_EP2PSendReliable : EP2PSend.k_EP2PSendUnreliable;

            SendPacket(connectionUsers[connectionId], buffer, (uint)count, ep2p);
        }
示例#16
0
        public void SendP2PPacket(SteamID steamID, byte[] data, EP2PSend sendType, int channel = 0)
        {
            IntPtr num = Marshal.AllocHGlobal(data.Length);

            Marshal.Copy(data, 0, num, data.Length);
            Networking.SteamUnityAPI_SteamNetworking_SendP2PPacket(this._networking, steamID.ToUInt64(), num, (uint)data.Length, (byte)sendType, channel);
            Marshal.FreeHGlobal(num);
        }
示例#17
0
 private bool SendP2PPacket(bool isServer, CSteamID id, byte[] data, int length, EP2PSend mode)
 {
     if (isServer)
     {
         return(SteamGameServerNetworking.SendP2PPacket(id, data, (uint)length, mode, 0));
     }
     return(SteamNetworking.SendP2PPacket(id, data, (uint)length, mode, 0));
 }
示例#18
0
 protected void Send(CSteamID host, byte[] msgBuffer, EP2PSend sendType)
 {
     if (!SteamManager.Initialized)
     {
         throw new ObjectDisposedException("Steamworks");
     }
     SteamNetworking.SendP2PPacket(host, msgBuffer, (uint)msgBuffer.Length, sendType, (int)SteamChannels.SEND_DATA);
 }
示例#19
0
    /// <summary>
    /// Send the transform given to game.
    /// </summary>
    public static void SendTransformToInGameUsers(Transform transform, EP2PSend sendType, bool sendToSender = true)
    {
        instance.WriteTransformOnPacketData(transform, true);

        byte[] packet = new byte[instance.Packet.CurrentSeek];
        Array.Copy(instance.Packet.Data, 0, packet, 0, packet.Length);
        Client.SendPacketToInGameUsers(packet, PacketType.ServerTransform, sendType, sendToSender);
    }
示例#20
0
    /// <summary>
    /// Send the transform given to the lobby.
    /// </summary>
    public static void SendTransformToLobby(Transform transform, PacketType command, EP2PSend sendType, bool sendToSender = true)
    {
        instance.WriteTransformOnPacketData(transform, true);

        byte[] packet = new byte[instance.Packet.CurrentSeek];
        Array.Copy(instance.Packet.Data, 0, packet, 0, packet.Length);
        Client.SendPacketToLobby(packet, command, sendType, sendToSender);
    }
        /*public int Send(byte[] dgram, int bytes)
		{
			CheckDisposed();
			if (dgram == null)
				throw new ArgumentNullException("dgram");

			if (!active)
				throw new InvalidOperationException("Operation not allowed on " +
					"non-connected Sockets.");

			return (DoSend(dgram, bytes, null));
		}*/

        public int Send(byte[] dgram, int bytes, CSteamID steamId, EP2PSend type = EP2PSend.k_EP2PSendUnreliable)
        {
            CheckDisposed();
            if (dgram == null)
                throw new ArgumentNullException("dgram is null");

            return (DoSend(dgram, bytes, steamId, type));
        }
示例#22
0
        public static void SendP2PMessage(CSteamID clientID, Message msg, EP2PSend sendType)
        {
            byte[] msg_array = Converter.ObjectToByteArray(msg);
            uint   size      = (uint)msg_array.Length; // Another way to calculate size, dont know if it works

            // SteamGameServerNetworking.SendP2PPacket(clientID, msg_array, (uint)Marshal.SizeOf(msg_array), sendType);
            SteamNetworking.SendP2PPacket(clientID, msg_array, size, sendType);
        }
示例#23
0
        public ConnectionStream(PacketDistributor packetDistributor, CSteamID remote, int channelID, EP2PSend reliability)
        {
            Remote      = remote;
            ChannelID   = channelID;
            Reliability = reliability;

            this.packetDistributor            = packetDistributor;
            packetDistributor.PacketReceived += OnPacketReceived;
        }
示例#24
0
        private void InputManager_Update(On.InputManager.orig_Update orig, InputManager self)
        {
            KeyCode key = (KeyCode)Enum.Parse(typeof(KeyCode), (mod.settings as PingSettings).Key);

            if (Input.GetKeyDown(key))
            {
                // First, find the mouse position as a unity vector
                // Next, spawn something there that lasts for x seconds
                // Finally, remove it after those seconds pass
                IGameCameraService gameCameraManager = Services.GetService <IGameCameraService>();
                GameNetworkManager net    = GameObject.FindObjectOfType <GameNetworkManager>();
                IMessageBox        msgBox = new DynData <GameNetworkManager>(net).Get <IMessageBox>("messageBox");

                RaycastHit[] array = Physics.RaycastAll(gameCameraManager.ScreenPointToRay(Input.mousePosition), float.PositiveInfinity);
                Array.Sort <RaycastHit>(array, (RaycastHit hitInfo1, RaycastHit hitInfo2) => hitInfo1.distance.CompareTo(hitInfo2.distance));

                // In theory the first raycast hit should be the best?
                // Not sure if this is the case...
                Vector3 mousePos = array[0].point;

                mod.Log("Raycast hits:");
                foreach (RaycastHit ra in array)
                {
                    mod.Log("Dist: " + ra.distance + " with pos: " + ra.point);
                }

                mod.Log("Mouse pos: " + mousePos.ToString());

                bool assert = (bool)typeof(GameNetworkManager).GetMethod("AssertMessageBoxIsSet", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Invoke(net, new object[0]);
                if (assert && msgBox != null && net != null)
                {
                    PingMessage pm = new PingMessage();
                    pm.SetPos(mousePos);
                    Message m = pm as Message;

                    mod.Log("Assertion: " + assert);
                    mod.Log("Net: " + net.name);
                    mod.Log("MSG BOX: " + msgBox.ToString());

                    EP2PSend temp = msgBox.SteamNetworkingSendMode;
                    msgBox.SteamNetworkingSendMode = EP2PSend.k_EP2PSendReliable;
                    msgBox.SendMessage(ref m, net.GetLobbyPlayerIDs());
                    msgBox.SteamNetworkingSendMode = temp;

                    mod.Log("Attempting to display!");
                }
                else
                {
                    GameObject obj = new GameObject("PING OBJECT");
                    PingScript p   = obj.AddComponent <PingScript>();
                    p.pos = mousePos;
                    mod.Log("It seems the game is not in multiplayer, attempting to create a local ping!");
                }
            }
            orig(self);
        }
示例#25
0
 public static void SendExcludeP2P(CSteamID excludeID, Message message, EP2PSend sendType)
 {
     for (int i = 0; i < players.Count; i++)
     {
         if (players[i] != excludeID)
         {
             SendP2P(players[i], message, sendType);
         }
     }
 }
示例#26
0
 void SendToHost(byte[] data, PacketType command, CSteamID sender, EP2PSend sendType)
 {
     if (lobby.Owner != (CSteamID)0)
     {
         Send(data, command, sender, lobby.Owner, sendType);
     }
     else if (Server.Host != (CSteamID)0)
     {
         Send(data, command, sender, Server.Host, sendType);
     }
 }
        public static void SendPackets(P2PPackage data, EP2PSend send, bool IncludeSelf = true)
        {
            //SendUnreliable – 小包,可以丢失,不需要依次发送,但要快
            //SendUnreliableNoDelay –     跟上面一样,但是不做链接检查,因为这样,它可能被丢失,但是这种方式是最快的传送方式。
            //SendReliable – 可靠的信息,大包,依次收发。
            //SendReliableWithBuffering –     跟上面一样,但是在发送前会缓冲数据,如果你发送大量的小包,它不会那么及时。(可能会延迟200ms)
            var ms = new MemoryStream();

            new BinaryFormatter().Serialize(ms, data);
            SendPacketsToAll(ms.GetBuffer(), send, IncludeSelf);
        }
示例#28
0
    /// <summary>
    /// Send the transform given to game.
    /// </summary>
    /// /// <param name="data">buffer to include in the final packet in addition to the transform. Data will be written before the transform.</param>
    public static void SendTransformToInGameUsers(byte[] data, Transform transform, EP2PSend sendType, bool sendToSender = true)
    {
        instance.Packet.CurrentSeek   = 0;
        instance.Packet.CurrentLength = 0;

        instance.Packet.WriteByteData(data, 0, data.Length);

        instance.WriteTransformOnPacketData(transform, false);

        Client.SendPacketToInGameUsers(instance.Packet.Data, 0, instance.Packet.CurrentLength, PacketType.PlayerDataServer, sendType, sendToSender);
    }
示例#29
0
    /// <summary>
    /// Send the transform given to the lobby.
    /// </summary>
    /// /// <param name="data">buffer to include in the final packet in addition to the transform. Data will be written before the transform.</param>
    public static void SendTransformToLobby(byte[] data, Transform transform, EP2PSend sendType, bool sendToSender = true)
    {
        instance.Packet.CurrentSeek = 0;

        instance.Packet.WriteByteData(data, 0, data.Length);

        instance.WriteTransformOnPacketData(transform, false);

        byte[] packet = new byte[instance.Packet.CurrentSeek];
        Array.Copy(instance.Packet.Data, 0, packet, 0, packet.Length);
        Client.SendPacketToLobby(packet, PacketType.ServerTransform, sendType, sendToSender);
    }
示例#30
0
 protected void Send(CSteamID host, byte[] msgBuffer, EP2PSend sendType, int channel)
 {
     if (!SteamManager.Initialized)
     {
         throw new ObjectDisposedException("Steamworks");
     }
     if (channel >= channels.Length)
     {
         channel = 0;
     }
     SteamNetworking.SendP2PPacket(host, msgBuffer, (uint)msgBuffer.Length, sendType, channel);
 }
示例#31
0
文件: Networking.cs 项目: Zeludon/FEZ
 public void SendP2PPacket(SteamID steamID, byte[] data, EP2PSend sendType, int channel = 0)
 {
   IntPtr num = Marshal.AllocHGlobal(data.Length);
   Marshal.Copy(data, 0, num, data.Length);
   Networking.SteamUnityAPI_SteamNetworking_SendP2PPacket(this._networking, steamID.ToUInt64(), num, (uint) data.Length, (byte) sendType, channel);
   Marshal.FreeHGlobal(num);
 }
示例#32
0
        /// <summary>
        /// Flushes all unflushed data, then sends the packet using a specified send type, and channel.
        ///	See:
        /// <see cref="SteamGameServerNetworking.SendP2PPacket"/>
        /// <seealso cref="SteamNetworking.SendP2PPacket"/>
        /// </summary>
        /// <param name="sendType">The type of send for Steam to use.</param>
        /// <param name="nChannel">The channel for steam to pass data through, might want to make sure you add this channel to the client channel list.</param>
        /// <param name="recipients">Who to send the packet to, leave empty for everyone on the server on the send call.</param>
        public bool Send(EP2PSend sendType, int nChannel, params CSteamID[] recipients)
        {
            Flush();

            byte[] bytes = Bytes;

            bool sent = false;

            if(bytes.Length <= 0)
            {
                throw new InvalidOperationException("Tried to send a packet with no data.");
            }

            if (_Server != null)
            {
                if (recipients.Length > 0)
                {
                    foreach (CSteamID player in recipients)
                    {
                        sent = SteamGameServerNetworking.SendP2PPacket(player, bytes, (uint)bytes.Length, sendType, nChannel);
                    }
                }
                else
                {
                    foreach (CSteamID player in _Server.Players.Keys)
                    {
                        sent = SteamGameServerNetworking.SendP2PPacket(player, bytes, (uint)bytes.Length, sendType, nChannel);
                    }
                }
            }
            else
            {
                sent = SteamNetworking.SendP2PPacket(_Client.ConnectedTo, bytes, (uint)bytes.Length, sendType, nChannel);
            }

            // Dispose unnessary objects.
            Dispose();
            return sent;
        }
		/// <summary>
		/// <para>//////////////////////////////////////////////////////////////////////////////////////////</para>
		/// <para> Session-less connection functions</para>
		/// <para>    automatically establishes NAT-traversing or Relay server connections</para>
		/// <para> Sends a P2P packet to the specified user</para>
		/// <para> UDP-like, unreliable and a max packet size of 1200 bytes</para>
		/// <para> the first packet send may be delayed as the NAT-traversal code runs</para>
		/// <para> if we can't get through to the user, an error will be posted via the callback P2PSessionConnectFail_t</para>
		/// <para> see EP2PSend enum above for the descriptions of the different ways of sending packets</para>
		/// <para> nChannel is a routing number you can use to help route message to different systems 	- you'll have to call ReadP2PPacket()</para>
		/// <para> with the same channel number in order to retrieve the data on the other end</para>
		/// <para> using different channels to talk to the same user will still use the same underlying p2p connection, saving on resources</para>
		/// </summary>
		public static bool SendP2PPacket(CSteamID steamIDRemote, byte[] pubData, uint cubData, EP2PSend eP2PSendType, int nChannel = 0) {
			InteropHelp.TestIfAvailableGameServer();
			return NativeMethods.ISteamGameServerNetworking_SendP2PPacket(steamIDRemote, pubData, cubData, eP2PSendType, nChannel);
		}
示例#34
0
		public static extern bool ISteamGameServerNetworking_SendP2PPacket(CSteamID steamIDRemote, [In, Out] byte[] pubData, uint cubData, EP2PSend eP2PSendType, int nChannel);
示例#35
0
文件: Networking.cs 项目: Zeludon/FEZ
 public void SendP2PPacket(SteamID steamID, string data, EP2PSend sendType, int channel = 0)
 {
   Networking.SteamUnityAPI_SteamNetworking_SendP2PPacket(this._networking, steamID.ToUInt64(), Marshal.StringToHGlobalAnsi(data), (uint) data.Length, (byte) sendType, channel);
 }