private void HandleBatchPacket(BatchPacket packet)
{
byte[] data = CompressionManager.DecompressionZlib(new BinaryStream(packet.Payload), true);
using (NetworkStream stream = new NetworkStream(data))
{
while (!stream.IsEndOfStream())
{
int len = stream.ReadVarInt();
byte[] payload = stream.ReadBytes(len);
_logger.Info(payload[0].ToString("X"));
DataPacket pk = Protocol.GetDefinedPacket(payload[0]).ValueOrFailure();
pk.SetBuffer(payload);
pk.DecodeHeader();
pk.DecodePayload();
_players.TryGetValue(packet.EndPoint, out IServerPlayer player);
player?.HandleDataPacket(pk);
}
}
packet.Dispose();
}
public static string TestBatch(LeagueServer server, ClientID client, string args)
{
var batched = new BatchPacket();
var packet1 = new UnitAddEXP();
packet1.TargetNetID = (NetID)0x40000001;
packet1.ExpAmmount = 100.0f;
var packet2 = new BuyItemAns();
packet2.SenderNetID = (NetID)0x40000001;
packet2.Item.ItemID = (ItemID)3100;
packet2.Item.ItemsInSlot = 1;
var packet3 = new BuyItemAns();
packet3.SenderNetID = (NetID)0x40000001;
packet3.Item.ItemID = (ItemID)3025;
packet3.Item.ItemsInSlot = 1;
packet3.Item.Slot = 2;
batched.Packets.Add(packet1);
batched.Packets.Add(packet2);
batched.Packets.Add(packet3);
server.SendEncrypted(client, ChannelID.Broadcast, batched);
return("Batched!");
}
public void AddPacketBatchQueue(MinecraftPacket packet, int reliability, int flags = RakNetProtocol.FlagNormal)
{
packet.Encode();
byte[] buffer = packet.ToArray();
BinaryStream st = new BinaryStream();
st.WriteVarInt((int)buffer.Length);
st.WriteBytes(buffer);
if (Server.Instance.Config.PacketDebug)
{
Logger.Debug("%server.network.minecraft.sendPacket", packet.PacketID.ToString("X"), packet.Length);
}
BatchPacket pk = new BatchPacket();
if (packet is FullChunkDataPacket)
{
pk.CompressionLevel = CompressionLevel.Optimal;
}
pk.Payload = st.ToArray();
string endPointStr = this.EndPoint.ToString();
Player player = null;
Server.Instance.Network.Players.TryGetValue(endPointStr, out player);
if (player == null)
{
return;
}
RakNetBatchPacketSendEventArgs ev = new RakNetBatchPacketSendEventArgs(this, player, pk);
Server.Instance.Event.Network.OnRakNetBatchPacketSend(this, ev);
if (ev.IsCancel)
{
return;
}
pk = ev.Packet;
this.QueueConnectedPacket(pk, reliability, packet.OrderChannel, flags);
}
public void SendPacket(Player player, DataPacket pk, bool immediate = false)
{
RakNetSession session = this.server.GetSession(player.EndPoint);
if (session == null)
{
return;
}
DataPacketSendArgs args = new DataPacketSendArgs(player, pk);
ServerEvents.OnPacketSend(args);
if (args.IsCancel)
{
return;
}
pk.Encode();
byte[] buffer = pk.ToArray();
BinaryStream st = new BinaryStream();
st.WriteVarInt((int)pk.Length);
st.WriteBytes(buffer);
BatchPacket bp = new BatchPacket();
bp.Payload = st.ToArray();
bp.Encode();
RakNet.Packets.EncapsulatedPacket enc = new RakNet.Packets.EncapsulatedPacket();
enc.buffer = bp.ToArray();
enc.reliability = RakNet.Packets.PacketReliability.RELIABLE;
enc.messageIndex = ++session.MessageIndex;
//Logger.Log("%server_packet_send", buffer[0].ToString("X"), buffer.Length);
session.SendPacket(enc, immediate);
}
public void HandleBatchPacket(BatchPacket packet)
{
string endPointStr = this.EndPoint.ToString();
if (this.Manager.Players.ContainsKey(endPointStr))
{
Player player = this.Manager.Players[endPointStr];
RakNetBatchPacketReceiveEventArgs ev = new RakNetBatchPacketReceiveEventArgs(this, player, packet);
Server.Instance.Event.Network.OnRakNetBatchPacketReceive(this, ev);
if (ev.IsCancel)
{
return;
}
packet = ev.Packet;
this.HandleMinecraftPacket(packet, player);
}
}
public void SendDataPacket(DataPacket packet, bool needAck = false,
Reliability reliability = Reliability.Reliable,
CompressionLevel compressionLevel = CompressionLevel.Fastest)
{
packet.EncodeHeader();
packet.EncodePayload();
NetworkStream stream = new NetworkStream();
stream.WriteVarInt((int)packet.Length);
stream.WriteBytes(packet.GetBuffer());
byte[] payload = CompressionManager.CompressionZlib(stream, compressionLevel, true);
BatchPacket batch = new BatchPacket();
batch.Payload = payload;
batch.EndPoint = ClientPeer.PeerEndPoint;
ClientPeer.SendEncapsulatedPacket(batch, reliability, packet.Channel);
}
public void HandleBatchPacket(RakNetSession session, byte[] buffer)
{
string id = RakNetServer.IPEndPointToID(session.EndPoint);
if (this.players.ContainsKey(id))
{
Player player = this.players[id];
int pkid = buffer[0];
if (pkid == BatchPacket.ID)
{
using (BatchPacket batch = new BatchPacket())
{
batch.SetBuffer(buffer);
batch.Decode();
this.GetPackets(batch, player);
}
}
}
}
public void HandleMinecraftPacket(BatchPacket pk, Player player)
{
using (BinaryStream stream = new BinaryStream(pk.Payload))
{
while (!stream.EndOfStream)
{
int len = stream.ReadVarInt();
byte[] buffer = stream.ReadBytes(len);
MinecraftPacket packet = this.Manager.GetMinecraftPacket(buffer[0], buffer);
if (packet != null)
{
/*DataPacketReceiveArgs args = new DataPacketReceiveArgs(player, pk);
* ServerEvents.OnPacketReceive(args);
*
* if (args.IsCancel)
* {
* return;
* }*/
if (Server.Instance.Config.PacketDebug)
{
Logger.Debug("%server.network.minecraft.receivePacket", buffer[0].ToString("X"),
buffer.Length);
}
Server.Instance.Invoke(() => player.OnPacketHandle(packet.Clone()));
}
else
{
if (Server.Instance.Config.PacketDebug)
{
Logger.Debug("%server.network.minecraft.notHandle", buffer[0].ToString("X"));
}
}
}
}
}
async void GetPackets(BatchPacket pk, Player player)
{
await Task.Run(() =>
{
using (BinaryStream stream = new BinaryStream(pk.Payload))
{
while (!stream.EndOfStream)
{
int len = stream.ReadVarInt();
byte[] buffer = stream.ReadBytes(len);
using (DataPacket packet = GetPacket(buffer[0]))
{
if (packet != null)
{
//Logger.Log("%server_packet_handle", buffer[0].ToString("X"), buffer.Length);
packet.SetBuffer(buffer);
packet.Decode();
DataPacketReceiveArgs args = new DataPacketReceiveArgs(player, pk);
ServerEvents.OnPacketReceive(args);
if (args.IsCancel)
{
return;
}
player.PacketHandle(packet);
}
else
{
Logger.Log("%server_packet_notHandle", buffer[0].ToString("X"), buffer.Length);
}
}
}
}
});
}
public RakNetBatchPacketReceiveEventArgs(NetworkSession session, Player player, BatchPacket packet)
{
this.Session = session;
this.Player = player;
this.Packet = packet;
}
