public void AdminAccountSearchConstructorTest()
{
ClientVersion version = ClientVersion.vMAX;
AdminAccountSearch.AcctSearchType type = AdminAccountSearch.AcctSearchType.Username;
string term = "a username";
AdminAccountSearch target = new AdminAccountSearch(version, type, term);
PacketWriter writer = target.GetWriter();
ClientPacketId packetidActual = (ClientPacketId)writer.Packet[0];
ushort packetlen = (ushort)((writer.Packet[1] << 8) | writer.Packet[2]);
RemoteAdminSubCommand commandidActual = (RemoteAdminSubCommand)writer.Packet[3];
AdminAccountSearch.AcctSearchType typeActual = (AdminAccountSearch.AcctSearchType)writer.Packet[4];
string termActual = System.Text.Encoding.ASCII.GetString(writer.Packet, 5, packetlen - 6);
ClientPacketId packetidExpected = ClientPacketId.RemoteAdmin;
RemoteAdminSubCommand commandidExpected = RemoteAdminSubCommand.AccountSearch;
AdminAccountSearch.AcctSearchType typeExpected = type;
string termExpected = term;
Assert.AreEqual(packetidExpected, packetidActual);
Assert.AreEqual(commandidExpected, commandidActual);
Assert.AreEqual(termExpected, termActual);
}
/// <summary>
/// Sends message containing only packet id
/// </summary>
private static void SendOnlyPacketId(ClientPacketId packetId)
{
ByteBuffer buffer = new ByteBuffer();
buffer.WriteLong((long)packetId);
SendDataToServer(buffer.ToArray());
}
byte[] CreatePacket <T>(IPacket <T> data, ClientPacketId Id)
{
byte[] msg = data.GetPacketData();
byte[] header = CreateHeader(data, Id);
byte[] packet = CombineByte(header, msg);
return(packet);
}
public NetPacketHandler GetPacketHandler(ClientPacketId id)
{
if (!PacketHandlers.TryGetValue(id, out var packetHandler))
{
throw new Exception($"Missing packet handler for \"{id}\".");
}
return(packetHandler);
}
public void RegisterClientPacketHandler(ClientPacketId packetId, Action handler)
{
if (_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Error(this, $"Tried to register already existing client packet handler: {packetId}");
return;
}
_clientPacketHandlers[packetId] = iPacket => { handler(); };
}
public void DeregisterClientPacketHandler(ClientPacketId packetId)
{
if (!_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Error(this, $"Tried to remove non-existent client packet handler: {packetId}");
return;
}
_clientPacketHandlers.Remove(packetId);
}
public void DataRequest(ClientPacketId Id)
{
//No Packet
HeaderData headerData = new HeaderData();
HeaderSerializer HeaderSerializer = new HeaderSerializer();
headerData.Id = (byte)Id;
HeaderSerializer.Serialize(headerData);
byte[] msg = HeaderSerializer.GetSerializedData();
sendMsg.Enqueue(msg);
}
public void RegisterClientPacketHandler <T>(ClientPacketId packetId, GenericClientPacketHandler <T> packetHandler)
where T : IPacketData
{
if (_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Error(this, $"Tried to register already existing client packet handler: {packetId}");
return;
}
// We can't store these kinds of generic delegates in a dictionary,
// so we wrap it in a function that casts it
_clientPacketHandlers[packetId] = iPacket => { packetHandler((T)iPacket); };
}
/// <summary>
/// Register a packet handler for the given ID.
/// </summary>
/// <param name="packetId">The client packet ID.</param>
/// <param name="handler">The handler for the data.</param>
private void RegisterClientPacketHandler(
ClientPacketId packetId,
ClientPacketHandler handler
)
{
if (_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Error(this, $"Tried to register already existing client packet handler: {packetId}");
return;
}
_clientPacketHandlers[packetId] = handler;
}
public void SetPacketHandler(ClientPacketId id, NetPacketHandler packetHandler)
{
if (packetHandler == null)
{
throw new ArgumentNullException(nameof(packetHandler));
}
if (PacketHandlers.ContainsKey(id))
{
throw new ArgumentException($"A packet handler is already registered for \"{id}\".", nameof(id));
}
PacketHandlers.Add(id, packetHandler);
}
byte[] CreateHeader <T>(IPacket <T> data, ClientPacketId Id)
{
byte[] msg = data.GetPacketData();
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerData.Id = (byte)Id;
headerData.length = (short)msg.Length;
headerSerializer.Serialize(headerData);
byte[] header = headerSerializer.GetSerializedData();
return(header);
}
/// <summary>
/// Executes the correct packet handler corresponding to this packet data.
/// </summary>
/// <param name="packetId">The client packet ID for this data.</param>
/// <param name="packetData">The packet data instance.</param>
private void ExecuteClientPacketHandler(ClientPacketId packetId, IPacketData packetData)
{
if (!_clientPacketHandlers.ContainsKey(packetId))
{
Logger.Get().Warn(this, $"There is no client packet handler registered for ID: {packetId}");
return;
}
// Invoke the packet handler for this ID on the Unity main thread
ThreadUtil.RunActionOnMainThread(() => {
try {
_clientPacketHandlers[packetId].Invoke(packetData);
} catch (Exception e) {
Logger.Get().Error(this,
$"Exception occured while executing client packet handler for packet ID: {packetId}, message: {e.Message}, stacktrace: {e.StackTrace}");
}
});
}
public void LoginRequestConstructorTest()
{
string username = "******";
string password = "******";
ClientVersion version = ClientVersion.vMAX;
LoginRequest target = new LoginRequest(version, username, password, 5);
PacketWriter writer = target.GetWriter();
PacketBuffer buffer = new PacketBuffer(writer.Packet);
PacketReader reader = new PacketReader(version, buffer, (ushort)writer.Length);
ClientPacketId actualPacketID = (ClientPacketId)reader.ReadByte();
string actualUsername = reader.ReadFixedString(30);
string actualPassword = reader.ReadFixedString(30);
Assert.AreEqual(ClientPacketId.LoginRequest, actualPacketID);
Assert.AreEqual(username, actualUsername);
Assert.AreEqual(password, actualPassword);
}
public void SetPacketHandler <TPacket>(ClientPacketId id, Action <NetConnection, TPacket> handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
Codec.SetPacketHandler(id, delegate(
NetConnection connection,
NetBinaryReader packetReader,
NetPacketDecoder.PacketIdDefinition packetIdDefinition,
out int messageLength)
{
var status = connection.ReadPacket <TPacket>(packetReader, out var packet, out messageLength);
if (status != OperationStatus.Done)
{
return(status);
}
handler.Invoke(connection, packet);
return(OperationStatus.Done);
});
}
public PacketStructAttribute(ClientPacketId packetId) : this((int)packetId)
{
IsClientPacket = true;
}
/// <summary>
/// Register a packet handler for the given ID.
/// </summary>
/// <param name="packetId">The client packet ID.</param>
/// <param name="handler">The handler for the data.</param>
/// <typeparam name="T">The type of the packet data passed as parameter to the handler.</typeparam>
public void RegisterClientPacketHandler <T>(
ClientPacketId packetId,
GenericClientPacketHandler <T> handler
) where T : IPacketData => RegisterClientPacketHandler(packetId, iPacket => handler((T)iPacket));
public void SendGamePacket(ISerializable gamePacket, ClientPacketId packetId, string destinationAddress, ushort destinationPort)
{
SendGamePacket(gamePacket, RemoteConnectionType.Client, (uint)packetId, destinationAddress, destinationPort);
}
/// <summary>
/// Register a data-independent packet handler for the given ID.
/// </summary>
/// <param name="packetId">The client packet ID.</param>
/// <param name="handler">The handler for the data.</param>
public void RegisterClientPacketHandler(
ClientPacketId packetId,
Action handler
) => RegisterClientPacketHandler(packetId, _ => handler());
