public void WritePacket(Packet packet)
{
Write((byte)packet.GetPacketType());
//packet.WriteFlush(this);
}
/// <summary>
/// Broadcasts a packet to all authenticated clients
/// </summary>
/// <param name="packet"></param>
public void BroadcastToAuthenticated(Packet packet)
{
Client[] authClients = GetAuthenticatedClients();
if (authClients.Length == 0)
return;
packet.SetShared(Logger, authClients.Length);
System.Threading.Tasks.Parallel.ForEach(authClients, (client) => client.SendPacket(packet));
}
/// <summary>
/// Sends a packet in parallel to each nearby player.
/// </summary>
/// <param name="world">The world containing the coordinates.</param>
/// <param name="coords">The center coordinates.</param>
/// <param name="packet">The packet to send</param>
public void SendPacketToNearbyPlayers(WorldManager world, UniversalCoords coords, Packet packet, Client excludedClient = null)
{
Client[] nearbyClients = GetNearbyPlayers(world, coords).ToArray();
if (nearbyClients.Length == 0 || (excludedClient != null && nearbyClients.Length == 1))
return;
packet.SetShared(Logger, excludedClient == null ? nearbyClients.Length : nearbyClients.Length - 1);
Parallel.ForEach(nearbyClients, (client) =>
{
if (excludedClient != client)
client.SendPacket(packet);
});
}
/// <summary>
/// Broadcasts a packet to all authenticated clients
/// </summary>
/// <param name="packet"></param>
internal void BroadcastToAuthenticated(Packet packet)
{
Client[] authClients = GetAuthenticatedClients() as Client[];
if (authClients.Length == 0)
return;
packet.SetShared(Logger, authClients.Length);
Parallel.ForEach(authClients, (client) => client.SendPacket(packet));
}
public void SendPacket(Packet packet)
{
lock (PacketQueue)
PacketQueue.Enqueue(packet);
}
public PacketSentEventArgs(Packet Packet, Socket Socket, Client Client)
: base(Packet, Socket, Client)
{
}
/// <summary>
/// Sends a packet in parallel to each nearby player.
/// </summary>
/// <param name="world">The world containing the coordinates.</param>
/// <param name="coords">The center coordinates.</param>
/// <param name="packet">The packet to send</param>
internal void SendPacketToNearbyPlayers(WorldManager world, UniversalCoords coords, Packet packet, Client excludedClient = null)
{
Client[] nearbyClients = GetNearbyPlayersInternal(world, coords).ToArray();
if (nearbyClients.Length == 0)
return;
packet.SetShared(Logger, nearbyClients.Length);
Parallel.ForEach(nearbyClients, (client) =>
{
if (excludedClient != client)
client.SendPacket(packet);
else
packet.Release();
});
}
public void SendPacket(Packet packet)
{
if (!Running)
return;
packetsToBeSent.Enqueue(packet);
int newValue = Interlocked.Increment(ref _TimesEnqueuedForSend);
if ((newValue - 1) == 0)
Server.SendClientQueue.Enqueue(this);
//Logger.Log(Chraft.Logger.LogLevel.Info, "Sending packet: {0}", packet.GetPacketType().ToString());
_Player.Server.NetworkSignal.Set();
}
public void Send_Start(Packet packet = null)
{
if(!Running)
{
DisposeSendSystem();
return;
}
try
{
byte[] data;
if (packet == null)
{
if (packetsToBeSent.Count > 0)
{
if (!packetsToBeSent.TryDequeue(out packet))
{
Interlocked.Exchange(ref _TimesEnqueuedForSend, 0);
return;
}
packet.Write();
data = packet.GetBuffer();
if (packet.Async)
Send_Async(data);
else
{
Send_Sync(data);
while (Running && packetsToBeSent.Count > 0)
{
if (!packetsToBeSent.TryDequeue(out packet))
{
Interlocked.Exchange(ref _TimesEnqueuedForSend, 0);
return;
}
if (packet.Async)
break;
packet.Write();
data = packet.GetBuffer();
Send_Sync(data);
packet = null;
}
if (packet != null)
Send_Start(packet);
else
Interlocked.Exchange(ref _TimesEnqueuedForSend, 0);
}
}
else
Interlocked.Exchange(ref _TimesEnqueuedForSend, 0);
}
else
{
packet.Write();
data = packet.GetBuffer();
Send_Async(data);
}
}
catch (Exception e)
{
MarkToDispose();
DisposeSendSystem();
Logger.Log(Logger.LogLevel.Error, e.Message);
// TODO: log something?
}
}
public void SendPacket(Packet packet)
{
this.PacketHandler.SendPacket(packet);
}
private void SendPacketToAllNearbyPlayers(Packet packet)
{
Dictionary<int, Client> nearbyClients = new Dictionary<int, Client>();
int radius = Settings.Default.SightRadius;
for (int x = X - radius; x <= X + radius; ++x)
{
for (int z = Z - radius; z <= Z + radius; ++z)
{
Chunk c = World[x, z, false, false];
if (c != null)
{
foreach (Client client in c.GetClients())
{
if (!nearbyClients.ContainsKey(client.SessionID))
{
nearbyClients.Add(client.SessionID, client);
client.PacketHandler.SendPacket(packet);
}
}
}
}
}
}
public void Send_Sync_Packet(Packet packet)
{
packet.Write();
Send_Sync(packet.GetBuffer());
packet.Release();
}
private void SendPacketToAllNearbyPlayers(Packet packet)
{
Dictionary<int, Client> nearbyClients = new Dictionary<int, Client>();
int radius = Settings.Default.SightRadius;
int chunkX = Coords.ChunkX;
int chunkZ = Coords.ChunkZ;
for (int x = chunkX - radius; x <= chunkX + radius; ++x)
{
for (int z = chunkZ - radius; z <= chunkZ + radius; ++z)
{
Chunk c = World.GetChunkFromChunk(x, z, false, false);
if (c != null)
{
foreach (Client client in c.GetClients())
{
if (!nearbyClients.ContainsKey(client.Owner.SessionID))
{
nearbyClients.Add(client.Owner.SessionID, client);
client.SendPacket(packet);
}
}
}
}
}
}
private void SendPacket(Packet packet)
{
_packetsToSend.Enqueue(packet);
int sendRunning = Interlocked.CompareExchange(ref SendRunning, 1, 0);
if (sendRunning == 0)
_sendTask = Task.Factory.StartNew(Send);
}
public PacketEventArgs(Packet Packet, Socket Socket, Client Client)
{
this.Socket = Socket;
this.Client = Client;
this.Packet = Packet;
}
/// <summary>
/// Broadcasts a packet to all clients, optionally excluding the sender.
/// </summary>
/// <param name="packet">The packet to be broadcasted.</param>
/// <param name="excludeClient">The client to excluded; usually the sender.</param>
public void Broadcast(Packet packet, Client excludeClient = null)
{
foreach (Client c in GetClients())
{
if (excludeClient == null || c.EntityId != excludeClient.EntityId)
c.SendPacket(packet);
}
}
public PacketRecevedEventArgs(Packet Packet, Socket Socket, Client Client)
: base(Packet, Socket, Client)
{
}
/// <summary>
/// Broadcasts a packet to all authenticated clients
/// </summary>
/// <param name="packet"></param>
public void BroadcastToAuthenticated(Packet packet)
{
System.Threading.Tasks.Parallel.ForEach(this.GetAuthenticatedClients(), (client) =>
{
client.SendPacket(packet);
});
}
// TODO: This should be removed in favor of the one below
/// <summary>
/// Sends a packet in parallel to each nearby player.
/// </summary>
/// <param name="world">The world containing the coordinates.</param>
/// <param name="absCoords>The center coordinates.</param>
/// <param name="packet">The packet to send</param>
internal void SendPacketToNearbyPlayers(WorldManager world, AbsWorldCoords absCoords, Packet packet)
{
Client[] nearbyClients = GetNearbyPlayersInternal(world, UniversalCoords.FromAbsWorld(absCoords)).ToArray();
if (nearbyClients.Length == 0)
return;
packet.SetShared(Logger, nearbyClients.Length);
Parallel.ForEach(nearbyClients, (client) =>
{
client.SendPacket(packet);
});
}
/// <summary>
/// Sends a packet in parallel to each nearby player.
/// </summary>
/// <param name="world">The world containing the coordinates.</param>
/// <param name="x">The center X coordinate.</param>
/// <param name="y">The center Y coordinate.</param>
/// <param name="z">The center Z coordinate.</param>
/// <param name="packet">The packet to send</param>
public void SendPacketToNearbyPlayers(WorldManager world, double x, double y, double z, Packet packet)
{
System.Threading.Tasks.Parallel.ForEach(this.GetNearbyPlayers(world, x, y, z), (client) =>
{
client.PacketHandler.SendPacket(packet);
});
}
/// <summary>
/// Broadcasts a packet to all clients, optionally excluding the sender.
/// </summary>
/// <param name="packet">The packet to be broadcasted.</param>
/// <param name="excludeClient">The client to excluded; usually the sender.</param>
internal void Broadcast(Packet packet, IClient iExcludeClient = null)
{
Client[] clients = GetClients() as Client[];
if (clients.Length == 0)
return;
packet.SetShared(Logger, clients.Length);
Client excludeClient = iExcludeClient as Client;
foreach (Client c in clients)
{
if (excludeClient == null || c.Owner.EntityId != excludeClient.Owner.EntityId)
c.SendPacket(packet);
}
}
/// <summary>
/// Broadcasts a packet to all clients, optionally excluding the sender.
/// </summary>
/// <param name="packet">The packet to be broadcasted.</param>
/// <param name="excludeClient">The client to excluded; usually the sender.</param>
public void Broadcast(Packet packet, Client excludeClient = null)
{
Client[] clients = GetClients();
if (clients.Length == 0)
return;
packet.SetShared(Logger, clients.Length);
foreach (Client c in GetClients())
{
if (excludeClient == null || c.Owner.EntityId != excludeClient.Owner.EntityId)
c.SendPacket(packet);
}
}
public void SendPacket(Packet packet)
{
lock (QueueLock)
CurrentPacketQueue.Enqueue(packet);
ToSend.Set();
}
/// <summary>
/// Sends a packet in parallel to each nearby player.
/// </summary>
/// <param name="world">The world containing the coordinates.</param>
/// <param name="absCoords>The center coordinates.</param>
/// <param name="packet">The packet to send</param>
public void SendPacketToNearbyPlayers(WorldManager world, AbsWorldCoords absCoords, Packet packet)
{
Parallel.ForEach(this.GetNearbyPlayers(world, absCoords), (client) =>
{
client.SendPacket(packet);
});
}
