/// <summary>
/// Send packet to all
/// </summary>
public void SendPacketToAll
(
RakNet_Packet packet,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
if (server_peer.state != PeerState.RunAsServer)
{
return;
}
if (!packet.begin_write || !packet.end_write)
{
Debug.LogError("Can't send packet! Check Begin & End packet");
return;
}
for (int i = 0; i < connections.Count; i++)
{
server_peer.SendToClient(connections[i].guid, priority, reliability, channel);
}
}
/// <summary>
/// Sends a data packet to all clients.
/// </summary>
/// <param name="packet">The packet that should be send to all clients.</param>
/// <param name="reliability">The reliability of the packet.</param>
public void SendPacketToAll(IPacket packet, PacketReliability reliability)
{
this.server.SendPacketToAll(packet, reliability);
this.OnSendPacketToAll?.Invoke(
this,
new NotifyAboutCallEventArgs <IPacket, PacketReliability>(packet, reliability));
}
public void SendToServer(PacketPriority priority, PacketReliability reliability, NetChannel channel)
{
if (ptr != IntPtr.Zero)
{
NETSND_Send(ptr, guid, (int)priority, (int)reliability, (int)channel);
}
}
public void BroadcastBitStream(BitWriter bs, PacketReliability reliablity, int sequenceChannel = 0)
{
bs.FlushBits();
// #todo Incomplete LiteNet support for Span :(
server.SendToAll(bs.DataWritten.ToArray(), (byte)sequenceChannel, GetDeliveryMethod(reliablity));
}
internal void SendToAreaPlayers(BitStream stream, PacketPriority pp, PacketReliability pr)
{
uint[] keys = WorldObjects.World.getImportantKeysByPosition(this.Position.Data, 8000);
foreach (uint key in keys)
{
if (!sWorld.getWorld(this.Map).PlayerPositionList.ContainsKey(key))
{
continue;
}
List <WorldObjects.Character.Player> mobs = sWorld.getWorld(this.Map).PlayerPositionList[key];
foreach (WorldObjects.Character.Player m in mobs)
{
if (m == this)
{
continue;
}
float mD = (m.Position - this.Position).Length;
if (mD <= 8000)
{
using (RakNetGUID guid = m.GUID)
{
Program.server.ServerInterface.Send(stream, pp, pr, (char)0, guid, false);
}
}
}
}
}
/// <summary>
/// Send packet to all from list
/// </summary>
public void SendPacketToAllFromListJob
(
ulong[] list,
RakNet_Packet packet,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
if (server_peer.state != PeerState.RunAsServer)
{
return;
}
if (!packet.begin_write || !packet.end_write)
{
Debug.LogError("Can't send packet! Check Begin & End packet");
return;
}
_SendPacketToAllJob a = new _SendPacketToAllJob();
a.peer = (ulong)server_peer.ptr;
a.p = priority;
a.r = reliability;
a.c = channel;
a.array = new NativeArray <ulong>(list, Allocator.TempJob);
JobHandle jobHandle = a.Schedule(list.Length, 64);
jobHandle.Complete();
a.array.Dispose();
}
public void SendToClient(ulong guid, PacketPriority priority, PacketReliability reliability)
{
if (ptr != IntPtr.Zero)
{
NETSND_Send(ptr, guid, (int)priority, (int)reliability, (int)NetChannel.NET_EVENTS);
}
}
public void Send(BitWriter bs, PacketReliability reliablity, Connection connection, int sequenceChannel = 0)
{
bs.FlushBits();
var peer = server.GetPeerById((int)connection.id);
peer.Send(bs.DataWritten, (byte)sequenceChannel, GetDeliveryMethod(reliablity));
}
public void BroadcastBitStream(BitWriter bs, PacketReliability reliablity, int sequenceChannel)
{
bs.FlushBits();
foreach (var client in clients)
{
client.EnqueueMessage(bs);
}
}
public void Send(byte[] data, PacketReliability reliability)
{
var orderingIndex =
reliability == PacketReliability.UnreliableSequenced ?_sequencedWriteIndex++ :
reliability == PacketReliability.ReliableOrdered ? _orderedWriteIndex++ : 0;
if (GetHeaderLength(reliability, false) + data.Length >= MtuSize - UdpHeaderSize)
{
var chunks = new List <byte[]>();
var splitPacketId = _splitPacketId++;
var offset = 0;
while (offset < data.Length)
{
var length = MtuSize - UdpHeaderSize - GetHeaderLength(reliability, true);
if (length > data.Length - offset)
{
length = data.Length - offset;
}
var chunk = new byte[length];
Buffer.BlockCopy(data, offset, chunk, 0, length);
chunks.Add(chunk);
offset += length;
}
foreach (var chunk in chunks)
{
_sends.Add(new InternalPacket
{
Data = chunk,
Reliability = reliability,
OrderingIndex = (uint)orderingIndex,
OrderingChannel = 0,
SplitPacket = true,
SplitPacketId = (ushort)splitPacketId,
SplitPacketIndex = (uint)chunks.IndexOf(chunk),
SplitPacketCount = (uint)chunks.Count
});
}
}
else
{
_sends.Add(new InternalPacket
{
Data = data,
Reliability = reliability,
OrderingIndex = (uint)orderingIndex,
OrderingChannel = 0,
SplitPacket = false
});
}
}
public void Send(BitWriter bs, PacketReliability reliablity, int sequenceChannel = 0)
{
if (!IsConnected)
{
throw new Exception("Not connected");
}
server.EnqueueMessage(connection, bs);
}
static DeliveryMethod GetDeliveryMethod(PacketReliability reliability)
{
return(reliability switch {
PacketReliability.Unreliable => DeliveryMethod.Unreliable,
PacketReliability.UnreliableSequenced => DeliveryMethod.Sequenced,
PacketReliability.ReliableUnordered => DeliveryMethod.ReliableUnordered,
PacketReliability.ReliableOrdered => DeliveryMethod.ReliableOrdered,
PacketReliability.ReliableSequenced => DeliveryMethod.ReliableSequenced,
_ => throw new ArgumentException("reliability"),
});
public void Send(ISerializable data, PacketReliability reliability = PacketReliability.ReliableOrdered)
{
using var stream = new MemoryStream();
using var writer = new BitWriter(stream);
data.Serialize(writer);
_server.Send(stream.ToArray(), EndPoint, reliability);
}
public override uint Send(BitStream bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast, uint forceReceiptNumber)
{
uint ret = RakNetPINVOKE.RakPeer_Send__SWIG_2(swigCPtr, BitStream.getCPtr(bitStream), (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast, forceReceiptNumber);
if (RakNetPINVOKE.SWIGPendingException.Pending)
{
throw RakNetPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public override uint Send(string data, int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast)
{
uint ret = RakNetPINVOKE.RakPeer_Send__SWIG_1(swigCPtr, data, length, (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast);
if (RakNetPINVOKE.SWIGPendingException.Pending)
{
throw RakNetPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public virtual uint Send(string data, int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast, uint forceReceiptNumber)
{
uint ret = RakNetPINVOKE.RakPeerInterface_Send__SWIG_0(swigCPtr, data, length, (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast, forceReceiptNumber);
if (RakNetPINVOKE.SWIGPendingException.Pending)
{
throw RakNetPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public virtual uint Send(BitStream bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast)
{
uint ret = RakNetPINVOKE.RakPeerInterface_Send__SWIG_3(swigCPtr, BitStream.getCPtr(bitStream), (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast);
if (RakNetPINVOKE.SWIGPendingException.Pending)
{
throw RakNetPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public uint Send(byte[] inByteArray, int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast)
{
uint ret = RakNetPINVOKE.RakPeerInterface_Send__SWIG_4(swigCPtr, inByteArray, length, (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast);
if (RakNetPINVOKE.SWIGPendingException.Pending)
{
throw RakNetPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
/// <summary>
/// Send packet to target
/// </summary>
public void SendPacket
(
RakNet_Packet packet,
ulong guid,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
packet.SendToClient(guid, priority, reliability, channel);
}
/// <summary>
/// Send rpc to client
/// </summary>
public void SendRPC
(
byte packet_id,
ulong guid,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
server_peer?.BeginWrite();
server_peer?.Write(packet_id);
server_peer?.SendToClient(guid, priority, reliability, channel);
}
public void Set(SendPacketOptions other)
{
if (other != null)
{
m_ApiVersion = P2PInterface.SendpacketApiLatest;
LocalUserId = other.LocalUserId;
RemoteUserId = other.RemoteUserId;
SocketId = other.SocketId;
Channel = other.Channel;
Data = other.Data;
AllowDelayedDelivery = other.AllowDelayedDelivery;
Reliability = other.Reliability;
}
}
/// <summary>
/// Send RPC to all clients
/// </summary>
public void SendRPCToAll
(
byte packet_id,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
for (int i = 0; i < connections.Count; i++)
{
server_peer?.BeginWrite();
server_peer?.Write(packet_id);
server_peer?.SendToClient(connections[i].guid, priority, reliability, channel);
}
}
public void Send(byte[] data, ICollection <IPEndPoint> endpoints = null, bool broadcast = false,
PacketReliability reliability = PacketReliability.ReliableOrdered)
{
var recipients = broadcast || endpoints == null?_connections.Keys.ToArray() : endpoints;
foreach (var endpoint in recipients)
{
if (!_connections.ContainsKey(endpoint))
{
continue;
}
_connections[endpoint].Send(data, reliability);
}
}
/// <summary>
/// Send data to client (with payload)
/// </summary>
public void SendData
(
byte[] data,
ulong guid = 0,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
server_peer?.BeginWrite();
server_peer?.WriteBytes(data);
if (guid != 0)
{
server_peer?.SendToClient(guid, priority, reliability, channel);
}
}
public static int GetHeaderLength(PacketReliability reliability, bool splitPacket)
{
var length = 52;
if (reliability == PacketReliability.UnreliableSequenced ||
reliability == PacketReliability.ReliableOrdered)
{
length += 37;
}
if (splitPacket)
{
length += 80;
}
return(BitStream.BitsToBytes(length));
}
public unsafe void SendBytesToServer(byte[] bytes, PacketPriority priority, PacketReliability reliability, NetChannel channel)
{
if (ptr != IntPtr.Zero)
{
BeginWrite();
WriteBytes(bytes);
NETSND_Send(ptr, guid, (int)priority, (int)reliability, (int)channel);
if (debugLevel == RakDebugLevel.Medium)
{
Debug.Log("[Peer] [" + state + "] Sending data [packet_id=" + bytes[0] + "] [sz=" + bytes.Length + "]");
}
if (debugLevel == RakDebugLevel.Full)
{
Debug.Log("[Peer] [" + state + "] Sending data to server [packet_id=" + (RakNetPacketID)bytes[0] + "] [sz=" + bytes.Length + "]");
}
}
}
/// <summary>
/// Send data to all clients (with payload)
/// </summary>
public void SendDataToAll
(
byte[] data,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
if (server_peer.state != PeerState.RunAsServer)
{
return;
}
for (int i = 0; i < connections.Count; i++)
{
server_peer?.BeginWrite();
server_peer?.WriteBytes(data);
server_peer?.SendToClient(connections[i].guid, priority, reliability, channel);
}
}
public void Send(BitWriter bs, PacketReliability reliablity, Connection connection, int sequenceChannel)
{
bs.FlushBits();
LocalClientInterface targetClient = null;
foreach (var client in clients)
{
if (client.connection == connection)
{
targetClient = client;
break;
}
}
if (targetClient == null)
{
throw new Exception("Client not found.");
}
targetClient.EnqueueMessage(bs);
}
/// <summary>
/// Send data to server
/// </summary>
public void SendData
(
byte[] data,
PacketPriority priority = PacketPriority.IMMEDIATE_PRIORITY,
PacketReliability reliability = PacketReliability.RELIABLE,
NetChannel channel = NetChannel.NET_EVENTS
)
{
if (IsConnected)
{
client_peer?.BeginWrite();
client_peer?.WriteBytes(data);
client_peer?.SendToServer(priority, reliability, channel);
}
else
{
if (RakNet_Peer.debugLevel >= RakDebugLevel.Low)
{
Debug.LogError("[Client] Is not connected!");
}
}
}
/// <summary>
/// Sends an object to the target scene with the requested reliability and priority levels.
/// </summary>
/// <typeparam name="TData">The type of the parameter object.</typeparam>
/// <param name="scene">The target scene.</param>
/// <param name="route">The target route on the scene.</param>
/// <param name="data">The data that will be serialized then sent.</param>
/// <param name="priority">The priority level.</param>
/// <param name="reliability">The reliability level</param>
public static void Send <TData>(this Scene scene, string route, TData data, PacketPriority priority = PacketPriority.HIGH_PRIORITY, PacketReliability reliability = PacketReliability.RELIABLE_ORDERED)
{
scene.Host.Send(route, s =>
{
scene.Host.Serializer().Serialize(data, s);
}, priority, reliability);
}
public uint Send(byte[] inByteArray, int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast) {
uint ret = RakNetPINVOKE.RakPeerInterface_Send__SWIG_4(swigCPtr, inByteArray, length, (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast);
if (RakNetPINVOKE.SWIGPendingException.Pending) throw RakNetPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public virtual uint Send(BitStream bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast) {
uint ret = RakNetPINVOKE.RakPeerInterface_Send__SWIG_3(swigCPtr, BitStream.getCPtr(bitStream), (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast);
if (RakNetPINVOKE.SWIGPendingException.Pending) throw RakNetPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public virtual uint Send(string data, int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast, uint forceReceiptNumber) {
uint ret = RakNetPINVOKE.RakPeerInterface_Send__SWIG_0(swigCPtr, data, length, (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast, forceReceiptNumber);
if (RakNetPINVOKE.SWIGPendingException.Pending) throw RakNetPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public override uint Send(string data, int length, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast) {
uint ret = RakNetPINVOKE.RakPeer_Send__SWIG_1(swigCPtr, data, length, (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast);
if (RakNetPINVOKE.SWIGPendingException.Pending) throw RakNetPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public override uint Send(BitStream bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier, bool broadcast, uint forceReceiptNumber) {
uint ret = RakNetPINVOKE.RakPeer_Send__SWIG_2(swigCPtr, BitStream.getCPtr(bitStream), (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier), broadcast, forceReceiptNumber);
if (RakNetPINVOKE.SWIGPendingException.Pending) throw RakNetPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ReplicaReturnResult Serialize(ref bool sendTimestamp, BitStream outBitStream, uint lastSendTime, ref PacketPriority priority, ref PacketReliability reliability, uint currentTime, SystemAddress systemAddress, SWIGTYPE_p_unsigned_int flags)
{
return ReplicaReturnResult.REPLICA_CANCEL_PROCESS;
}
public uint Send(FT_Session session, FT_DataBase data, PacketPriority priority, PacketReliability reliability, char orderingChannel, AddressOrGUID systemIdentifier) {
uint ret = RakNetPINVOKE.FT_Node_Plugin_Send__SWIG_1(swigCPtr, FT_Session.getCPtr(session), FT_DataBase.getCPtr(data), (int)priority, (int)reliability, orderingChannel, AddressOrGUID.getCPtr(systemIdentifier));
if (RakNetPINVOKE.SWIGPendingException.Pending) throw RakNetPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ReplicaReturnResult Serialize(ref bool sendTimestamp, BitStream outBitStream, uint lastSendTime, ref PacketPriority priority, ref PacketReliability reliability, uint currentTime, SystemAddress systemAddress, SWIGTYPE_p_unsigned_int flags)
{
if (lastSendTime == 0)
Console.Write("First call to Player::Serialize for {0}:{1}\n", systemAddress.binaryAddress, systemAddress.port);
outBitStream.Write(position);
outBitStream.Write(health);
return ReplicaReturnResult.REPLICA_PROCESSING_DONE;
}
/// <summary>
/// Sends a packet to the scene.
/// </summary>
/// <param name="route">A string containing the route on which the message should be sent.</param>
/// <param name="writer">An action called.</param>
/// <returns>A task completing when the transport takes</returns>
public void SendPacket(string route, Action<Stream> writer, PacketPriority priority = PacketPriority.MEDIUM_PRIORITY, PacketReliability reliability = PacketReliability.RELIABLE)
{
if (route == null)
{
DependencyResolver.GetComponent<ILogger>().Error("SendPacket failed: Tried to send a meesage on null route");
throw new ArgumentNullException("no route selected");
}
if (writer == null)
{
DependencyResolver.GetComponent<ILogger>().Error("SendPacket failed: Tried to send message with a null writer");
throw new ArgumentNullException("no writer given");
}
if (!this.Connected)
{
DependencyResolver.GetComponent<ILogger>().Error("SendPacket failed: Tried to send message without being connected");
throw new InvalidOperationException("The scene must be connected to perform this operation.");
}
Route routeObj;
if (!_remoteRoutesMap.TryGetValue(route, out routeObj))
{
DependencyResolver.GetComponent<ILogger>().Error("SendPacket failed: The route '{1}' doesn't exist on the scene.", route);
throw new ArgumentException("The route " + route + " doesn't exist on the scene.");
}
_peer.SendToScene(this.Handle, routeObj.Handle, writer, priority, reliability);//.SendPacket(routeObj, writer, priority, reliability, channel);
}
public override ReplicaReturnResult Serialize(ref bool sendTimestamp, BitStream outBitStream, uint lastSendTime, ref PacketPriority priority, ref PacketReliability reliability, uint currentTime, SystemAddress systemAddress, SWIGTYPE_p_unsigned_int flags)
{
return Listener.Serialize(ref sendTimestamp, outBitStream, lastSendTime, ref priority, ref reliability, currentTime, systemAddress, flags);
}
