public static void HandleServerTrainerBuy(Packet packet)
{
packet.ReadGuid("GUID");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_0_3_13329))
{
packet.ReadInt32("Unk");
}
packet.ReadInt32 <SpellId>("Spell ID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_TRAINER_BUY_FAILED, Direction.ServerToClient) ||
packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_TRAINER_BUY_RESULT, Direction.ServerToClient))
{
packet.ReadUInt32("Reason");
}
}
public static void HandleTalentPreviewTalents(Packet packet)
{
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_LEARN_PREVIEW_TALENTS_PET, Direction.ClientToServer))
{
packet.ReadGuid("GUID");
}
var count = packet.ReadUInt32("Talent Count");
for (var i = 0; i < count; ++i)
{
packet.ReadUInt32("Talent ID", i);
packet.ReadUInt32("Rank", i);
}
}
public static void HandleAuctionListBidderItems(Packet packet)
{
packet.ReadGuid("Auctioneer GUID");
packet.ReadUInt32("List From");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_AUCTION_LIST_OWNER_ITEMS))
{
return;
}
var count = packet.ReadUInt32("Outbidded Count");
for (var i = 0; i < count; ++i)
{
packet.ReadUInt32("Auction Id", i);
}
}
public static void HandleSoundMessages(Packet packet)
{
var sound = packet.ReadUInt32("Sound Id");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_3_0_15005))
{
packet.ReadGuid("GUID");
}
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_PLAY_OBJECT_SOUND))
{
packet.ReadGuid("GUID 2");
}
Storage.Sounds.Add(sound, packet.TimeSpan);
}
public static void HandleQuestcompleteQuest(Packet packet)
{
packet.ReadGuid("GUID");
packet.ReadEntryWithName <UInt32>(StoreNameType.Quest, "Quest ID");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_3_0_15005))
{
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_QUESTGIVER_REQUEST_REWARD))
{
packet.ReadUInt32("Unk UInt32 1");
}
else
{
packet.ReadByte("Unk UInt32 1");
}
}
}
public static void HandleQuestgiverStatus(Packet packet)
{
uint count = 1;
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_QUESTGIVER_STATUS_MULTIPLE))
{
count = packet.ReadUInt32("Count");
}
var typeCode = ClientVersion.AddedInVersion(ClientVersionBuild.V4_2_0_14333) ? TypeCode.Int32 : TypeCode.Byte;
for (int i = 0; i < count; i++)
{
packet.ReadGuid("GUID", i);
packet.ReadEnum <QuestGiverStatus>("Status", typeCode, i);
}
}
public static void HandleThreatlistUpdate(Packet packet)
{
packet.ReadPackedGuid("GUID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_HIGHEST_THREAT_UPDATE))
{
packet.ReadPackedGuid("New Highest");
}
var count = packet.ReadUInt32("Size");
for (int i = 0; i < count; i++)
{
packet.ReadPackedGuid("Hostile", i);
packet.ReadUInt32("Threat", i);
}
}
private void lv_windowLoadData(UInt16 i_address)
{
lv_dissassembly.Clear();
lv_dissassembly.Columns.Add("Address", 70);
lv_dissassembly.Columns.Add("Opcode", 70);
lv_dissassembly.Columns.Add("Instruction", 200);
UInt16 lo_val = (i_address < 0x00FF) ? (UInt16)(0) : (UInt16)(i_address - 0xFF);
UInt16 hi_val = ((UInt32)(i_address + 0x00FF) > 0xFFFF) ? (UInt16)(0xFFFF) : (UInt16)(i_address + 0xFF);
for (UInt16 i = lo_val; i < hi_val;)
{
Byte opcode = Program.emulator.GetMemory().ReadFromMemory(i);
String address = String.Format("{0:X4}", i);
String value = String.Format("{0:X2}", opcode);
ListViewItem item = new ListViewItem(address);
item.SubItems.Add(value);
if ((Opcodes.Opcode)opcode == Opcodes.Opcode.OPCODE_INTERNAL_CB)
{
opcode = Program.emulator.GetMemory().ReadFromMemory(++i);
item.SubItems.Add(OpcodesCB.GetOpcodeCB((OpcodesCB.OpcodeCB)opcode, ref i));
}
else
{
item.SubItems.Add(Opcodes.GetOpcode((Opcodes.Opcode)opcode, ref i));
}
lv_dissassembly.Items.Add(item);
}
if (lv_dissassembly.Items.Count == 0)
{
return;
}
int index = GetItemIndexWithAddress(String.Format("{0:X4}", i_address));
ListViewItem sel_item = lv_dissassembly.Items[index];
sel_item.Selected = true;
sel_item.Focused = true;
lv_dissassembly.Select();
lv_dissassembly.EnsureVisible(index);
}
public static void HandleTalentPreviewTalents434(Packet packet)
{
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_LEARN_PREVIEW_TALENTS_PET))
{
packet.ReadGuid("GUID");
}
else
{
packet.ReadUInt32("Tab Page");
}
var count = packet.ReadUInt32("Talent Count");
for (var i = 0; i < count; ++i)
{
packet.ReadUInt32("Talent ID", i);
packet.ReadUInt32("Rank", i);
}
}
public static void HandleSpecialMoveAckMessages(Packet packet)
{
var guid = packet.ReadPackedGuid();
packet.Writer.WriteLine("GUID: " + guid);
var unk1 = packet.ReadInt32();
packet.Writer.WriteLine("Unk Int32 1: " + unk1);
ReadMovementInfo(ref packet, guid);
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_MOVE_KNOCK_BACK_ACK))
{
return;
}
var unk2 = packet.ReadInt32();
packet.Writer.WriteLine("Unk Int32 2: " + unk2);
}
public static void HandleCollisionMovements(Packet packet)
{
var guid = packet.ReadPackedGuid();
packet.Writer.WriteLine("GUID: " + guid);
if (packet.Opcode != Opcodes.GetOpcode(Opcode.MSG_MOVE_SET_COLLISION_HGT))
{
var counter = packet.ReadInt32();
packet.Writer.WriteLine("Movement Counter: " + counter);
}
if (packet.Opcode != Opcodes.GetOpcode(Opcode.SMSG_MOVE_SET_COLLISION_HGT))
{
ReadMovementInfo(ref packet, guid);
}
var unk = packet.ReadSingle();
packet.Writer.WriteLine("Collision Height: " + unk);
}
public static void ReadLfgRewardBlock(ref Packet packet)
{
packet.ReadBoolean("First Completion");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_LFG_PLAYER_REWARD))
{
packet.ReadInt32("Strangers");
}
packet.ReadInt32("Base Money");
packet.ReadInt32("Base XP");
packet.ReadInt32("Variable Money");
packet.ReadInt32("Variable XP");
var numFields = packet.ReadByte("Reward Item Count");
for (var i = 0; i < numFields; i++)
{
packet.ReadEntryWithName <Int32>(StoreNameType.Item, "Reward Item Id", i);
packet.ReadInt32("Reward Item Display ID", i);
packet.ReadInt32("Reward Item Stack Count", i);
}
}
public static void HandleMovementMessages(Packet packet)
{
Guid guid;
if (ClientVersion.AddedInVersion(ClientVersionBuild.V3_2_0_10192) ||
packet.Direction == Direction.ServerToClient)
{
guid = packet.ReadPackedGuid("GUID");
}
else
{
guid = new Guid();
}
ReadMovementInfo(ref packet, guid);
if (packet.Opcode == Opcodes.GetOpcode(Opcode.MSG_MOVE_KNOCK_BACK))
{
packet.ReadSingle("Sin Angle");
packet.ReadSingle("Cos Angle");
packet.ReadSingle("Speed");
packet.ReadSingle("Velocity");
}
}
public static void ReadQueryHeader(Packet packet)
{
var entry = packet.ReadInt32("Entry");
var guid = packet.ReadGuid("GUID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_QUERY_CREATURE, Direction.ClientToServer) || packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_QUERY_GAME_OBJECT, Direction.ClientToServer))
{
if (guid.HasEntry() && (entry != guid.GetEntry()))
{
packet.AddValue("Error", "Entry does not match calculated GUID entry");
}
}
}
public static void ReadPlayerMovementInfo(ref Packet packet, params MovementStatusElements[] movementStatusElements)
{
var guid = new byte[8];
var transportGUID = new byte[8];
var pos = new Vector4();
var transportPos = new Vector4();
bool hasMovementFlags = false;
bool hasMovementFlags2 = false;
bool hasTimestamp = false;
bool hasOrientation = false;
bool hasTransportData = false;
bool hasTransportTime2 = false;
bool hasTransportTime3 = false;
bool hasPitch = false;
bool hasFallData = false;
bool hasFallDirection = false;
bool hasSplineElevation = false;
bool hasUnkTime = false;
bool hasUnkBitA = false;
uint count = 0;
foreach (var movementInfo in movementStatusElements)
{
switch (movementInfo)
{
case MovementStatusElements.MSEHasGuidByte0:
guid[0] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte1:
guid[1] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte2:
guid[2] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte3:
guid[3] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte4:
guid[4] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte5:
guid[5] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte6:
guid[6] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte7:
guid[7] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasTransportGuidByte0:
if (hasTransportData)
{
transportGUID[0] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte1:
if (hasTransportData)
{
transportGUID[1] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte2:
if (hasTransportData)
{
transportGUID[2] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte3:
if (hasTransportData)
{
transportGUID[3] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte4:
if (hasTransportData)
{
transportGUID[4] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte5:
if (hasTransportData)
{
transportGUID[5] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte6:
if (hasTransportData)
{
transportGUID[6] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte7:
if (hasTransportData)
{
transportGUID[7] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEGuidByte0:
packet.ReadXORByte(guid, 0);
break;
case MovementStatusElements.MSEGuidByte1:
packet.ReadXORByte(guid, 1);
break;
case MovementStatusElements.MSEGuidByte2:
packet.ReadXORByte(guid, 2);
break;
case MovementStatusElements.MSEGuidByte3:
packet.ReadXORByte(guid, 3);
break;
case MovementStatusElements.MSEGuidByte4:
packet.ReadXORByte(guid, 4);
break;
case MovementStatusElements.MSEGuidByte5:
packet.ReadXORByte(guid, 5);
break;
case MovementStatusElements.MSEGuidByte6:
packet.ReadXORByte(guid, 6);
break;
case MovementStatusElements.MSEGuidByte7:
packet.ReadXORByte(guid, 7);
break;
case MovementStatusElements.MSETransportGuidByte0:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 0);
}
break;
case MovementStatusElements.MSETransportGuidByte1:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 1);
}
break;
case MovementStatusElements.MSETransportGuidByte2:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 2);
}
break;
case MovementStatusElements.MSETransportGuidByte3:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 3);
}
break;
case MovementStatusElements.MSETransportGuidByte4:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 4);
}
break;
case MovementStatusElements.MSETransportGuidByte5:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 5);
}
break;
case MovementStatusElements.MSETransportGuidByte6:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 6);
}
break;
case MovementStatusElements.MSETransportGuidByte7:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 7);
}
break;
case MovementStatusElements.MSEHasMovementFlags:
hasMovementFlags = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasMovementFlags2:
hasMovementFlags2 = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasTimestamp:
hasTimestamp = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasOrientation:
hasOrientation = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasTransportData:
hasTransportData = packet.ReadBit();
break;
case MovementStatusElements.MSEHasTransportTime2:
if (hasTransportData)
{
hasTransportTime2 = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportTime3:
if (hasTransportData)
{
hasTransportTime3 = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasPitch:
hasPitch = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasFallData:
hasFallData = packet.ReadBit();
break;
case MovementStatusElements.MSEHasFallDirection:
if (hasFallData)
{
hasFallDirection = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasSplineElevation:
hasSplineElevation = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasSpline:
packet.ReadBit("hasSpline");
break;
case MovementStatusElements.MSECounterCount:
count = packet.ReadBits(22);
break;
case MovementStatusElements.MSECount:
packet.ReadInt32("Counter");
break;
case MovementStatusElements.MSECounter:
for (var i = 0; i < count; i++)
{
packet.ReadInt32("Unk Int", i);
}
break;
case MovementStatusElements.MSEMovementFlags:
if (hasMovementFlags)
{
packet.ReadEnum <MovementFlag>("Movement Flags", 30);
}
break;
case MovementStatusElements.MSEMovementFlags2:
if (hasMovementFlags2)
{
packet.ReadEnum <MovementFlagExtra>("Extra Movement Flags", 13);
}
break;
case MovementStatusElements.MSETimestamp:
if (hasTimestamp)
{
packet.ReadInt32("Timestamp");
}
break;
case MovementStatusElements.MSEPositionX:
pos.X = packet.ReadSingle();
break;
case MovementStatusElements.MSEPositionY:
pos.Y = packet.ReadSingle();
break;
case MovementStatusElements.MSEPositionZ:
pos.Z = packet.ReadSingle();
break;
case MovementStatusElements.MSEOrientation:
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_MOVE_TELEPORT))
{
pos.O = packet.ReadSingle();
}
else
{
if (hasOrientation)
{
pos.O = packet.ReadSingle();
}
}
break;
case MovementStatusElements.MSETransportPositionX:
if (hasTransportData)
{
transportPos.X = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportPositionY:
if (hasTransportData)
{
transportPos.Y = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportPositionZ:
if (hasTransportData)
{
transportPos.Z = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportOrientation:
if (hasTransportData)
{
transportPos.O = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportSeat:
if (hasTransportData)
{
packet.ReadByte("Seat");
}
break;
case MovementStatusElements.MSETransportTime:
if (hasTransportData)
{
packet.ReadInt32("Transport Time");
}
break;
case MovementStatusElements.MSETransportTime2:
if (hasTransportData && hasTransportTime2)
{
packet.ReadInt32("Transport Time 2");
}
break;
case MovementStatusElements.MSETransportTime3:
if (hasTransportData && hasTransportTime3)
{
packet.ReadInt32("Transport Time 3");
}
break;
case MovementStatusElements.MSEPitch:
if (hasPitch)
{
packet.ReadSingle("Pitch");
}
break;
case MovementStatusElements.MSEFallTime:
if (hasFallData)
{
packet.ReadInt32("Fall time");
}
break;
case MovementStatusElements.MSEFallVerticalSpeed:
if (hasFallData)
{
packet.ReadSingle("Vertical Speed");
}
break;
case MovementStatusElements.MSEFallCosAngle:
if (hasFallData && hasFallDirection)
{
packet.ReadSingle("Fall Angle");
}
break;
case MovementStatusElements.MSEFallSinAngle:
if (hasFallData && hasFallDirection)
{
packet.ReadSingle("Fall Sin");
}
break;
case MovementStatusElements.MSEFallHorizontalSpeed:
if (hasFallData && hasFallDirection)
{
packet.ReadSingle("Horizontal Speed");
}
break;
case MovementStatusElements.MSESplineElevation:
if (hasSplineElevation)
{
packet.ReadSingle("Spline elevation");
}
break;
case MovementStatusElements.MSEHasUnkTime:
hasUnkTime = !packet.ReadBit();
break;
case MovementStatusElements.MSEUnkTime:
if (hasUnkTime)
{
packet.ReadInt32("Unk Time");
}
break;
case MovementStatusElements.MSEZeroBit:
case MovementStatusElements.MSEOneBit:
packet.ReadBit();
break;
case MovementStatusElements.MSEHasUnkBitA:
hasUnkBitA = packet.ReadBit();
break;
case MovementStatusElements.MSEUnkBitABit:
if (hasUnkBitA)
{
packet.ReadBit("UnkBitABit");
}
break;
case MovementStatusElements.MSEUnkBitAByte:
if (hasUnkBitA)
{
packet.ReadByte("MSEUnkBitAByte");
}
break;
}
}
if (hasTransportData)
{
packet.WriteGuid("Transport Guid", transportGUID);
packet.AddValue("Transport Position", transportPos);
}
if (pos.X != 0 && pos.Y != 0 && pos.Z != 0)
{
packet.AddValue("Position", pos);
}
packet.WriteGuid("Guid", guid);
}
public static void HandlePartyMemberStats(Packet packet)
{
/*
* -- UNK PACKET
* var count = packet.ReadBits("counter", 18);
*
* var unkGuid = new byte[count][];
* var unkLen = new uint[count];
* var unkLen2 = new uint[count];
* var count2 = new uint[count];
* var bit28 = new bool[count];
* var bit16 = new bool[count];
*
* for (int i = 0; i < count; i++)
* {
* unkGuid[i] = new byte[8];
*
* count2[i] = packet.ReadBits("counter2", 17, i);
* bit16[i] = packet.ReadBit("bit16", i);
*
* if (bit16[i])
* packet.StartBitStream(unkGuid[i], 3, 6, 4, 2, 5, 1, 0, 7);
*
* bit28[i] = packet.ReadBit("bit28", i);
* unkLen[i] = packet.ReadBits("unkLen", 13, i);
* unkLen2[i] = packet.ReadBits("unkLen2", 8, i);
*
* for (int j = 0; j < count2[i]; j++)
* packet.ReadBit("unkBit", i, j);
* }
*
* for (int i = 0; i < count; i++)
* {
* for (int j = 0; j < count2[i]; j++)
* {
* packet.ReadUInt32("unk UInt32", i, j);
* packet.ReadUInt32("unk UInt32", i, j);
*
* for (int y = 0; y < 8; y++)
* {
* packet.ReadUInt32("unk UInt32", i, j, y);
* packet.ReadUInt32("unk UInt32", i, j, y);
* packet.ReadUInt32("unk UInt32", i, j, y);
* }
*
* packet.ReadUInt32("unk UInt32", i, j);
* packet.ReadByte("unk Byte", i, j);
* packet.ReadUInt32("unk UInt32", i, j);
* packet.ReadUInt32("unk UInt32", i, j);
* packet.ReadUInt32("unk UInt32", i, j);
* packet.ReadUInt32("unk UInt32", i, j);
* var bytesCounter = packet.ReadUInt32("unk UInt32", i, j);
* if (bytesCounter > 0)
* packet.ReadBytes((int)bytesCounter);
* packet.ReadUInt32("unk UInt32", i, j);
* }
*
* packet.ReadUInt32("unk UInt32", i);
*
* if (bit16[i])
* {
* packet.ParseBitStream(unkGuid[i], 2, 0, 4, 5, 3, 6, 1, 7);
* packet.WriteGuid("Unk GUID", unkGuid[i], i);
* }
*
* packet.ReadWoWString("unkString2", unkLen2[i], i);
* packet.ReadUInt32("unk UInt32", i);
* packet.ReadUInt32("unk UInt32", i);
* packet.ReadUInt64("unk UInt64", i);
* packet.ReadUInt32("unk UInt32", i);
* packet.ReadUInt64("unk UInt64", i);
* packet.ReadUInt32("unk UInt32", i);
* packet.ReadWoWString("unkString", unkLen[i], i);
*
* if (bit28[i])
* packet.ReadUInt32("unk UInt32", i);
*
* packet.ReadByte("unk Byte", i);
* packet.ReadUInt32("unk UInt32", i);
* }
*
* packet.ReadUInt32("unk UInt32");*/
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) &&
packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_PARTY_MEMBER_STATS_FULL))
{
packet.ReadBoolean("Add arena opponent");
}
packet.ReadPackedGuid("GUID");
var updateFlags = packet.ReadEnum <GroupUpdateFlag>("Update Flags", TypeCode.UInt32);
if (updateFlags.HasFlag(GroupUpdateFlag.Status))
{
packet.ReadEnum <GroupMemberStatusFlag>("Status", TypeCode.Int16);
}
if (updateFlags.HasFlag(GroupUpdateFlag.CurrentHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Current Health");
}
else
{
packet.ReadUInt16("Current Health");
}
}
if (updateFlags.HasFlag(GroupUpdateFlag.MaxHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Max Health");
}
else
{
packet.ReadUInt16("Max Health");
}
}
if (updateFlags.HasFlag(GroupUpdateFlag.PowerType))
{
packet.ReadEnum <PowerType>("Power type", TypeCode.Byte);
}
if (updateFlags.HasFlag(GroupUpdateFlag.CurrentPower))
{
packet.ReadInt16("Current Power");
}
if (updateFlags.HasFlag(GroupUpdateFlag.MaxPower))
{
packet.ReadInt16("Max Power");
}
if (updateFlags.HasFlag(GroupUpdateFlag.Level))
{
packet.ReadInt16("Level");
}
if (updateFlags.HasFlag(GroupUpdateFlag.Zone))
{
packet.ReadEntryWithName <Int16>(StoreNameType.Zone, "Zone Id");
}
if (updateFlags.HasFlag(GroupUpdateFlag.Position))
{
packet.ReadInt16("Position X");
packet.ReadInt16("Position Y");
}
if (updateFlags.HasFlag(GroupUpdateFlag.Auras))
{
var auraMask = packet.ReadUInt64("Aura Mask");
var maxAura = ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) ? 64 : 56;
for (var i = 0; i < maxAura; ++i)
{
if ((auraMask & (1ul << i)) == 0)
{
continue;
}
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadEntryWithName <UInt32>(StoreNameType.Spell, "Spell Id", i);
}
else
{
packet.ReadEntryWithName <UInt16>(StoreNameType.Spell, "Spell Id", i);
}
packet.ReadEnum <AuraFlag>("Aura Flags", TypeCode.Byte, i);
}
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetGuid))
{
packet.ReadGuid("Pet GUID");
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetName))
{
packet.ReadCString("Pet Name");
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetModelId))
{
packet.ReadInt16("Pet Modelid");
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetCurrentHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Pet Current Health");
}
else
{
packet.ReadUInt16("Pet Current Health");
}
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetMaxHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Pet Max Health");
}
else
{
packet.ReadUInt16("Pet Max Health");
}
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetPowerType))
{
packet.ReadEnum <PowerType>("Pet Power type", TypeCode.Byte);
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetCurrentPower))
{
packet.ReadInt16("Pet Current Power");
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetMaxPower))
{
packet.ReadInt16("Pet Max Power");
}
if (updateFlags.HasFlag(GroupUpdateFlag.PetAuras))
{
var auraMask = packet.ReadUInt64("Pet Auramask");
var maxAura = ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) ? 64 : 56;
for (var i = 0; i < maxAura; ++i)
{
if ((auraMask & (1ul << i)) == 0)
{
continue;
}
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadEntryWithName <UInt32>(StoreNameType.Spell, "Spell Id", i);
}
else
{
packet.ReadEntryWithName <UInt16>(StoreNameType.Spell, "Spell Id", i);
}
packet.ReadEnum <AuraFlag>("Aura Flags", TypeCode.Byte, i);
}
}
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) && // no idea when this was added exactly, doesn't exist in 2.4.1
updateFlags.HasFlag(GroupUpdateFlag.VehicleSeat))
{
packet.ReadInt32("Vehicle Seat");
}
}
private static void LoadHandlersInto(Dictionary <KeyValuePair <ClientVersionBuild, Opcode>, Action <Packet> > handlers, Assembly asm, ClientVersionBuild build)
{
var types = asm.GetTypes();
foreach (var type in types)
{
//if (type.Namespace != "WowPacketParser.Parsing.Parsers")
// continue;
if (!type.IsAbstract)
{
continue;
}
if (!type.IsPublic)
{
continue;
}
var methods = type.GetMethods();
foreach (var method in methods)
{
if (!method.IsPublic)
{
continue;
}
var attrs = (ParserAttribute[])method.GetCustomAttributes(typeof(ParserAttribute), false);
if (attrs.Length <= 0)
{
continue;
}
var parms = method.GetParameters();
if (parms.Length <= 0)
{
continue;
}
if (parms[0].ParameterType != typeof(Packet))
{
continue;
}
foreach (var attr in attrs)
{
var opc = attr.Opcode;
if (opc == Opcode.NULL_OPCODE)
{
continue;
}
var key = new KeyValuePair <ClientVersionBuild, Opcode>(build, opc);
var del = (Action <Packet>)Delegate.CreateDelegate(typeof(Action <Packet>), method);
if (handlers.ContainsKey(key))
{
Trace.WriteLine(string.Format("Error: (Build: {0}) tried to overwrite delegate for opcode {1} ({2}); new handler: {3}; old handler: {4}",
ClientVersion.Build, Opcodes.GetOpcode(attr.Opcode), attr.Opcode, del.Method, handlers[key].Method));
continue;
}
handlers[key] = del;
}
}
}
}
public static void Parse(Packet packet, bool isMultiple = false)
{
ParsedStatus status;
var opcode = Opcodes.GetOpcode(packet.Opcode, packet.Direction);
if (opcode == Opcode.NULL_OPCODE)
{
opcode = Opcodes.GetOpcode(packet.Opcode);
}
packet.WriteLine(packet.GetHeader(isMultiple));
if (packet.Opcode == 0)
{
return;
}
var key = new KeyValuePair <ClientVersionBuild, Opcode>(ClientVersion.VersionDefiningBuild, opcode);
Action <Packet> handler;
var hasHandler = VersionHandlers.TryGetValue(key, out handler);
if (!hasHandler)
{
key = new KeyValuePair <ClientVersionBuild, Opcode>(ClientVersionBuild.Zero, opcode);
hasHandler = VersionHandlers.TryGetValue(key, out handler);
}
if (hasHandler && Settings.DumpFormat != DumpFormatType.HexOnly)
{
if (Settings.DumpFormat == DumpFormatType.SniffDataOnly)
{
var attrs = handler.Method.GetCustomAttributes(typeof(HasSniffDataAttribute), false);
packet.AddSniffData(StoreNameType.Opcode, packet.Opcode, Opcodes.GetOpcodeName(packet.Opcode));
if (attrs.Length == 0)
{
packet.Status = ParsedStatus.NotParsed;
return; // skip parsing "useless" packets when in SniffData-only-mode
}
}
try
{
handler(packet);
if (packet.Position == packet.Length)
{
status = ParsedStatus.Success;
}
else
{
var pos = packet.Position;
var len = packet.Length;
packet.WriteLine("Packet not fully read! Current position is {0}, length is {1}, and diff is {2}.",
pos, len, len - pos);
if (len < 300) // If the packet isn't "too big" and it is not full read, print its hex table
{
packet.AsHex();
}
status = ParsedStatus.WithErrors;
}
}
catch (Exception ex)
{
packet.WriteLine(ex.GetType().ToString());
packet.WriteLine(ex.Message);
packet.WriteLine(ex.StackTrace);
status = ParsedStatus.WithErrors;
}
}
else
{
packet.AsHex();
status = ParsedStatus.NotParsed;
}
if (!isMultiple)
{
packet.Status = status;
if (Settings.DumpFormat != DumpFormatType.SniffDataOnly)
{
// added before for this type
var data = status == ParsedStatus.Success ? Opcodes.GetOpcodeName(packet.Opcode) : status.ToString();
packet.AddSniffData(StoreNameType.Opcode, packet.Opcode, data);
}
}
}
public static void HandleMonsterMove(Packet packet)
{
packet.ReadPackedGuid("GUID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_MONSTER_MOVE_TRANSPORT))
{
packet.ReadPackedGuid("Transport GUID");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V3_1_0_9767)) // no idea when this was added exactly
{
packet.ReadByte("Transport Seat");
}
}
if (ClientVersion.AddedInVersion(ClientVersionBuild.V3_1_0_9767)) // no idea when this was added exactly
{
packet.ReadBoolean("Unk Boolean"); // Something to do with IsVehicleExitVoluntary ?
}
var pos = packet.ReadVector3("Position");
packet.ReadInt32("Move Ticks");
var type = packet.ReadEnum <SplineType>("Spline Type", TypeCode.Byte);
switch (type)
{
case SplineType.FacingSpot:
{
packet.ReadVector3("Facing Spot");
break;
}
case SplineType.FacingTarget:
{
packet.ReadGuid("Facing GUID");
break;
}
case SplineType.FacingAngle:
{
packet.ReadSingle("Facing Angle");
break;
}
case SplineType.Stop:
return;
}
var flags = packet.ReadEnum <SplineFlag>("Spline Flags", TypeCode.Int32);
if (flags.HasAnyFlag(SplineFlag.AnimationTier))
{
packet.ReadEnum <MovementAnimationState>("Animation State", TypeCode.Byte);
packet.ReadInt32("Asynctime in ms"); // Async-time in ms
}
// Cannot find anything similar to this in 4.2.2 client
if (ClientVersion.RemovedInVersion(ClientVersionBuild.V4_2_2_14545))
{
if (flags.HasAnyFlag(SplineFlag.Falling)) // Could be SplineFlag.UsePathSmoothing
{
packet.ReadInt32("Unknown");
packet.ReadInt16("Unknown");
packet.ReadInt16("Unknown");
}
}
packet.ReadInt32("Move Time");
if (flags.HasAnyFlag(SplineFlag.Trajectory))
{
packet.ReadSingle("Vertical Speed");
packet.ReadInt32("Unk Int32 2");
}
var waypoints = packet.ReadInt32("Waypoints");
if (flags.HasAnyFlag(SplineFlag.Flying | SplineFlag.CatmullRom))
{
packet.ReadVector3("Waypoint", 0);
for (var i = 1; i < waypoints; i++)
{
packet.ReadVector3("Waypoint", i);
}
}
else
{
var newpos = packet.ReadVector3("Waypoint Endpoint");
var mid = new Vector3();
mid.X = (pos.X + newpos.X) * 0.5f;
mid.Y = (pos.Y + newpos.Y) * 0.5f;
mid.Z = (pos.Z + newpos.Z) * 0.5f;
for (var i = 1; i < waypoints; i++)
{
var vec = packet.ReadPackedVector3();
vec.X += mid.X;
vec.Y += mid.Y;
vec.Z += mid.Z;
packet.Writer.WriteLine("[" + i + "]" + " Waypoint: " + vec);
}
}
}
public static void HandleCombatLogMultiple(Packet packet)
{
var count = packet.ReadInt32("Count");
var unk1 = packet.ReadInt32();
for (var i = 0; i < count; i++)
{
var unk2 = packet.ReadInt32();
packet.AddValue("Unknown", unk1 - unk2, i);
var opcode = Opcodes.GetOpcode(packet.ReadInt32(), Direction.ServerToClient);
packet.AddValue("Opcode", opcode);
switch (opcode)
{
case Opcode.SMSG_SPELL_HEAL_LOG:
{
ReadSpellHealLog(packet, i);
break;
}
case Opcode.SMSG_SPELL_ENERGIZE_LOG:
{
ReadSpellEnergizeLog(packet, i);
break;
}
case Opcode.SMSG_SPELL_PERIODIC_AURA_LOG:
{
ReadPeriodicAuraLog(packet, i); // sub_5EEE10
break;
}
case Opcode.SMSG_SPELL_EXECUTE_LOG:
{
ReadSpellLogExecute(packet, i);
break;
}
case Opcode.SMSG_SPELL_NON_MELEE_DAMAGE_LOG:
{
ReadSpellNonMeleeDamageLog(packet, i);
break;
}
case Opcode.SMSG_SPELL_MISS_LOG:
{
ReadSpellMissLog(packet, i);
break;
}
case Opcode.SMSG_SPELL_STEAL_LOG:
case Opcode.SMSG_SPELL_DISPELL_LOG:
case Opcode.SMSG_SPELL_BREAK_LOG:
{
ReadSpellRemoveLog(packet, i);
break;
}
default:
throw new InvalidDataException("Unknown Spell Log Type/Opcode: " + opcode);
}
}
}
private static void LoadHandlersInto(Dictionary <KeyValuePair <ClientVersionBuild, Opcode>, Action <Packet> > handlers, Assembly asm, ClientVersionBuild build)
{
var types = asm.GetTypes();
foreach (Type type in types)
{
if (!type.IsAbstract || !type.IsPublic)
{
continue;
}
var methods = type.GetMethods();
foreach (MethodInfo method in methods)
{
if (!method.IsPublic)
{
continue;
}
var attrs = (ParserAttribute[])method.GetCustomAttributes(typeof(ParserAttribute), false);
if (attrs.Length <= 0)
{
continue;
}
var parms = method.GetParameters();
if (parms.Length <= 0)
{
continue;
}
if (parms[0].ParameterType != typeof(Packet))
{
continue;
}
foreach (ParserAttribute attr in attrs)
{
Opcode opc = attr.Opcode;
if (opc == Opcode.NULL_OPCODE)
{
continue;
}
var key = new KeyValuePair <ClientVersionBuild, Opcode>(build, opc);
var del = (Action <Packet>)Delegate.CreateDelegate(typeof(Action <Packet>), method);
if (handlers.ContainsKey(key))
{
// @TODO This is a hack to keep things easy regarding declaration of opcodes.
// Ideally, we would split the opcodes into three different enums:
// ClientOpcodes, ServerOpcodes, BidirectionalOpcodes
// The first two are obvious as to what they would contain.
// The last one would be MSG_, UMSG_, TEST_, etc... opcodes
// However that's just too much pain to do considering the mess Blizzard does
// by naming their opcodes sometimes without following their own rules.
Direction direction = attr.Opcode.ToString()[0] == 'S' ? Direction.ServerToClient : Direction.ClientToServer;
// ReSharper disable once UseStringInterpolation
Trace.WriteLine(string.Format("Error: (Build: {0}) tried to overwrite delegate for opcode {1} ({2}); new handler: {3}; old handler: {4}",
ClientVersion.Build, Opcodes.GetOpcode(attr.Opcode, direction), attr.Opcode, del.Method, handlers[key].Method));
continue;
}
handlers[key] = del;
}
}
}
}
public static void HandlePartyMemberStats(Packet packet)
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) &&
packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_PARTY_MEMBER_STATS_FULL))
{
packet.ReadBoolean("Add arena opponent");
}
packet.ReadPackedGuid("GUID");
var updateFlags = packet.ReadEnum <GroupUpdateFlag>("Update Flags", TypeCode.Int32);
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Status))
{
packet.ReadEnum <GroupMemberStatusFlag>("Status", TypeCode.Int16);
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.CurrentHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Current Health");
}
else
{
packet.ReadUInt16("Current Health");
}
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.MaxHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Max Health");
}
else
{
packet.ReadUInt16("Max Health");
}
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PowerType))
{
packet.ReadEnum <PowerType>("Power type", TypeCode.Byte);
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.CurrentPower))
{
packet.ReadInt16("Current Power");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.MaxPower))
{
packet.ReadInt16("Max Power");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Level))
{
packet.ReadInt16("Level");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Zone))
{
packet.ReadInt16("Zone ID");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Position))
{
packet.ReadInt16("Position X");
packet.ReadInt16("Position Y");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Auras))
{
var auraMask = packet.ReadUInt64("Auramask");
int maxAura = ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) ? 64 : 56;
for (var i = 0; i < maxAura; ++i)
{
if ((auraMask & ((ulong)1 << i)) != 0)
{
int aura;
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
aura = packet.ReadInt32();
}
else
{
aura = packet.ReadUInt16();
}
packet.Writer.WriteLine("Slot: [" + i + "] Spell ID: " + StoreGetters.GetName(StoreNameType.Spell, aura));
packet.ReadEnum <AuraFlag>("Slot: [" + i + "] Aura flag", TypeCode.Byte);
}
}
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetGuid))
{
packet.ReadGuid("Pet GUID");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetName))
{
packet.ReadCString("Pet Name");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetModelId))
{
packet.ReadInt16("Pet Modelid");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetCurrentHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Pet Current Health");
}
else
{
packet.ReadUInt16("Pet Current Health");
}
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetMaxHealth))
{
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
packet.ReadInt32("Pet Max Health");
}
else
{
packet.ReadUInt16("Pet Max Health");
}
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetPowerType))
{
packet.ReadEnum <PowerType>("Pet Power type", TypeCode.Byte);
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetCurrentPower))
{
packet.ReadInt16("Pet Current Power");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetMaxPower))
{
packet.ReadInt16("Pet Max Power");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.PetAuras))
{
var auraMask = packet.ReadUInt64("Pet Auramask");
int maxAura = ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) ? 64 : 56;
for (var i = 0; i < maxAura; ++i)
{
if ((auraMask & ((ulong)1 << i)) != 0)
{
int aura;
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing))
{
aura = packet.ReadInt32();
}
else
{
aura = packet.ReadUInt16();
}
packet.Writer.WriteLine("Slot: [" + i + "] Spell ID: " + StoreGetters.GetName(StoreNameType.Spell, aura));
packet.ReadEnum <AuraFlag>("Slot: [" + i + "] Aura flag", TypeCode.Byte);
}
}
}
if (ClientVersion.AddedInVersion(ClientType.WrathOfTheLichKing) && // no idea when this was added exactly, doesn't exist in 2.4.1
updateFlags.HasAnyFlag(GroupUpdateFlag.VehicleSeat))
{
packet.ReadInt32("Vehicle Seat");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Unknown1))
{
packet.ReadInt32("Unk int32");
}
if (updateFlags.HasAnyFlag(GroupUpdateFlag.Unknown2))
{
packet.ReadInt32("Unk int32");
packet.ReadInt32("Unk int32");
packet.ReadCString("Unk string");
}
}
public static void ReadLfgRewardBlock(ref Packet packet)
{
packet.ReadBoolean("First Completion");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_LFG_PLAYER_REWARD))
{
packet.ReadInt32("Strangers");
}
packet.ReadInt32("Base Money");
packet.ReadInt32("Base XP");
packet.ReadInt32("Variable Money");
packet.ReadInt32("Variable XP");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_2_2_14545))
{
packet.ReadInt32("Unk 1");
packet.ReadInt32("Unk 2");
packet.ReadInt32("Unk 3");
packet.ReadInt32("Unk 4");
packet.ReadInt32("Unk 5");
packet.ReadInt32("Unk 6");
packet.ReadInt32("Unk 7");
packet.ReadInt32("Unk 8");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_3_4_15595)) // perhaps earlier, confirmed for 434
{
packet.ReadInt32("Unk 8.1");
}
packet.ReadByte("Unk 9");
// LFG_SLOT_INFO_LOOT related
for (var i = 0; i < 3; ++i)
{
var unk1 = packet.ReadInt32("Unk 1", i);
if (unk1 != 0)
{
packet.ReadInt32("Unk 2", i);
packet.ReadInt32("Unk 3", i);
var unk4 = packet.ReadByte("Unk 4", i);
for (var j = 0; j < unk4; ++j)
{
packet.ReadInt32("Unk 5", j);
packet.ReadInt32("Unk 6", j);
packet.ReadInt32("Unk 7", j);
packet.ReadByte("Unk 8", j);
}
}
}
packet.ReadInt32("Unk 10");
packet.ReadInt32("Unk 11");
}
var numFields = packet.ReadByte("Reward Item Count");
for (var i = 0; i < numFields; i++)
{
packet.ReadEntryWithName <Int32>(StoreNameType.Item, "Reward Item Or Currency Id", i);
packet.ReadInt32("Reward Item Display ID", i);
packet.ReadInt32("Reward Item Stack Count", i);
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_0_6a_13623))
{
packet.ReadBoolean("Is Currency", i);
}
}
}
public static void HandleSpellStart(Packet packet)
{
bool isSpellGo = packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_SPELL_GO);
packet.ReadPackedGuid("Caster GUID");
packet.ReadPackedGuid("Caster Unit GUID");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V3_0_2_9056))
{
packet.ReadByte("Cast Count");
}
packet.ReadEntryWithName <Int32>(StoreNameType.Spell, "Spell ID");
if (ClientVersion.RemovedInVersion(ClientVersionBuild.V3_0_2_9056) && !isSpellGo)
{
packet.ReadByte("Cast Count");
}
var flagsTypeCode = ClientVersion.AddedInVersion(ClientVersionBuild.V3_0_2_9056) ? TypeCode.Int32 : TypeCode.UInt16;
var flags = packet.ReadEnum <CastFlag>("Cast Flags", flagsTypeCode);
packet.ReadInt32("Time");
if (isSpellGo)
{
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_3_0_15005))
{
packet.ReadInt32("unk");
}
var hitCount = packet.ReadByte("Hit Count");
for (var i = 0; i < hitCount; i++)
{
packet.ReadGuid("Hit GUID", i);
}
var missCount = packet.ReadByte("Miss Count");
for (var i = 0; i < missCount; i++)
{
var missGuid = packet.ReadGuid("Miss GUID", i);
packet.Writer.WriteLine("Miss GUID " + i + ": " + missGuid);
var missType = packet.ReadEnum <SpellMissType>("Miss Type", TypeCode.Byte, i);
if (missType != SpellMissType.Reflect)
{
continue;
}
packet.ReadEnum <SpellMissType>("Miss Reflect", TypeCode.Byte, i);
}
}
else
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_3_0_15005))
{
packet.ReadInt32("unk");
}
var targetFlags = ReadSpellCastTargets(ref packet);
if (ClientVersion.AddedInVersion(ClientVersionBuild.V3_0_2_9056))
{
if (flags.HasAnyFlag(CastFlag.PredictedPower))
{
packet.ReadInt32("Rune Cooldown");
}
if (flags.HasAnyFlag(CastFlag.RuneInfo))
{
var spellRuneState = packet.ReadByte("Spell Rune State");
var playerRuneState = packet.ReadByte("Player Rune State");
for (var i = 0; i < 6; i++)
{
var mask = 1 << i;
if ((mask & spellRuneState) == 0)
{
continue;
}
if ((mask & playerRuneState) != 0)
{
continue;
}
packet.ReadByte("Rune Cooldown Passed", i);
}
}
if (isSpellGo)
{
if (flags.HasAnyFlag(CastFlag.AdjustMissile))
{
packet.ReadSingle("Unk Single");
packet.ReadInt32("Unk Int32 1");
}
}
}
if (flags.HasAnyFlag(CastFlag.Projectile))
{
packet.ReadInt32("Ammo Display ID");
packet.ReadEnum <InventoryType>("Ammo Inventory Type", TypeCode.Int32);
}
if (ClientVersion.AddedInVersion(ClientVersionBuild.V3_0_2_9056))
{
if (isSpellGo)
{
if (flags.HasAnyFlag(CastFlag.VisualChain))
{
packet.ReadInt32("Unk Int32 2");
packet.ReadInt32("Unk Int32 3");
}
if (targetFlags.HasAnyFlag(TargetFlag.DestinationLocation))
{
packet.ReadByte("Unk Byte 2");
}
if (targetFlags.HasAnyFlag(TargetFlag.ExtraTargets))
{
var targetCount = packet.ReadInt32("Extra Targets Count");
for (var i = 0; i < targetCount; i++)
{
packet.ReadVector3("Extra Target Position", i);
packet.ReadGuid("Extra Target GUID", i);
}
}
}
else
{
if (flags.HasAnyFlag(CastFlag.Immunity))
{
packet.ReadInt32("Unk Int32 4");
packet.ReadInt32("Unk Int32 5");
}
}
}
}
public ParserAttribute(int opcode)
{
Opcode = Opcodes.GetOpcode(opcode);
}
public static void ReadQueryHeader(ref Packet packet)
{
var entry = packet.ReadInt32("Entry");
var guid = packet.ReadGuid("GUID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_CREATURE_QUERY) || packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_GAMEOBJECT_QUERY))
{
if (guid.HasEntry() && (entry != guid.GetEntry()))
{
packet.WriteLine("Entry does not match calculated GUID entry");
}
}
}
public static void HandleCombatLogMultiple(Packet packet)
{
var count = packet.ReadInt32("Count");
var unk1 = packet.ReadInt32();
for (var i = 0; i < count; i++)
{
var unk2 = packet.ReadInt32();
packet.WriteLine("[" + i + "] Unknown: {0}", unk1 - unk2);
var opcode = Opcodes.GetOpcode(packet.ReadInt32());
packet.WriteLine("Opcode: " + opcode);
switch (opcode)
{
case Opcode.SMSG_SPELLHEALLOG:
{
ReadSpellHealLog(ref packet, i);
break;
}
case Opcode.SMSG_SPELLENERGIZELOG:
{
ReadSpellEnergizeLog(ref packet, i);
break;
}
case Opcode.SMSG_PERIODICAURALOG:
{
ReadPeriodicAuraLog(ref packet, i); // sub_5EEE10
break;
}
case Opcode.SMSG_SPELLLOGEXECUTE:
{
ReadSpellLogExecute(ref packet, i);
break;
}
case Opcode.SMSG_SPELLNONMELEEDAMAGELOG:
{
ReadSpellNonMeleeDamageLog(ref packet, i);
break;
}
case Opcode.SMSG_SPELLLOGMISS:
{
ReadSpellMissLog(ref packet, i);
break;
}
case Opcode.SMSG_SPELLSTEALLOG:
case Opcode.SMSG_SPELLDISPELLOG:
case Opcode.SMSG_SPELLBREAKLOG:
{
ReadSpellRemoveLog(ref packet, i);
break;
}
default:
throw new InvalidDataException("Unknown Spell Log Type/Opcode: " + opcode);
}
}
}
public static void HandleServerChatMessage(Packet packet)
{
PacketChat chatPacket = packet.Holder.Chat = new PacketChat();
var text = new CreatureText
{
Type = packet.ReadByteE <ChatMessageType>("Type"),
Language = packet.ReadInt32E <Language>("Language"),
SenderGUID = packet.ReadGuid("GUID")
};
packet.ReadInt32("Constant time");
switch (text.Type)
{
case ChatMessageType.Achievement:
case ChatMessageType.GuildAchievement:
{
packet.ReadGuid("Sender GUID");
break;
}
case ChatMessageType.WhisperForeign:
{
packet.ReadInt32("Name Length");
text.SenderName = packet.ReadCString("Name");
text.ReceiverGUID = packet.ReadGuid("Receiver GUID");
break;
}
case ChatMessageType.BattlegroundNeutral:
case ChatMessageType.BattlegroundAlliance:
case ChatMessageType.BattlegroundHorde:
{
var target = packet.ReadGuid("Sender GUID");
switch (target.GetHighType())
{
case HighGuidType.Creature:
case HighGuidType.Vehicle:
case HighGuidType.GameObject:
case HighGuidType.Transport:
case HighGuidType.Pet:
packet.ReadInt32("Sender Name Length");
packet.ReadCString("Sender Name");
break;
}
break;
}
case ChatMessageType.MonsterSay:
case ChatMessageType.MonsterYell:
case ChatMessageType.MonsterParty:
case ChatMessageType.MonsterEmote:
case ChatMessageType.MonsterWhisper:
case ChatMessageType.RaidBossEmote:
case ChatMessageType.RaidBossWhisper:
case ChatMessageType.BattleNet:
{
packet.ReadInt32("Name Length");
text.SenderName = packet.ReadCString("Name");
text.ReceiverGUID = packet.ReadGuid("Receiver GUID");
switch (text.ReceiverGUID.GetHighType())
{
case HighGuidType.Creature:
case HighGuidType.Vehicle:
case HighGuidType.GameObject:
case HighGuidType.Transport:
packet.ReadInt32("Receiver Name Length");
text.ReceiverName = packet.ReadCString("Receiver Name");
break;
}
break;
}
default:
{
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_GM_MESSAGECHAT, Direction.ServerToClient))
{
packet.ReadInt32("GMNameLength");
packet.ReadCString("GMSenderName");
}
if (text.Type == ChatMessageType.Channel)
{
packet.ReadCString("Channel Name");
}
packet.ReadGuid("Sender GUID");
break;
}
}
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_1_0_13914) && text.Language == Language.Addon)
{
packet.ReadCString("Addon Message Prefix");
}
packet.ReadInt32("Text Length");
text.Text = packet.ReadCString("Text");
if (ClientVersion.AddedInVersion(ClientVersionBuild.V5_1_0_16309))
{
packet.ReadInt16E <ChatTag>("Chat Tag");
}
else
{
packet.ReadByteE <ChatTag>("Chat Tag");
}
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_2_0_14333))
{
if (text.Type == ChatMessageType.RaidBossEmote || text.Type == ChatMessageType.RaidBossWhisper)
{
packet.ReadSingle("Unk single");
packet.ReadByte("Unk byte");
}
}
if (text.Type == ChatMessageType.Achievement || text.Type == ChatMessageType.GuildAchievement)
{
packet.ReadInt32 <AchievementId>("Achievement Id");
}
uint entry = 0;
if (text.SenderGUID.GetObjectType() == ObjectType.Unit)
{
entry = text.SenderGUID.GetEntry();
}
else if (text.ReceiverGUID != null && text.ReceiverGUID.GetObjectType() == ObjectType.Unit)
{
entry = text.ReceiverGUID.GetEntry();
}
if (entry != 0)
{
Storage.CreatureTexts.Add(entry, text, packet.TimeSpan);
}
chatPacket.Text = text.Text;
chatPacket.Sender = text.SenderGUID.ToUniversalGuid();
chatPacket.Target = text.ReceiverGUID?.ToUniversalGuid();
chatPacket.Language = (int)text.Language;
chatPacket.Type = (int)text.Type;
}
public static void ReadLfgRewardBlock(Packet packet, object index)
{
packet.ReadBool("First Completion", index);
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_LFG_PLAYER_REWARD, Direction.ServerToClient))
{
packet.ReadInt32("Strangers", index);
}
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_2_2_14545))
{
packet.ReadInt32("currencyQuantity", index);
packet.ReadInt32("Unk 2", index);
packet.ReadInt32("currencyID", index);
packet.ReadInt32("tier1Quantity", index);
packet.ReadInt32("tier1Limit", index);
packet.ReadInt32("overallQuantity", index);
packet.ReadInt32("overallLimit", index);
packet.ReadInt32("periodPurseQuantity", index);
packet.ReadInt32("periodPurseLimit", index);
packet.ReadInt32("purseQuantity", index);
packet.ReadInt32("purseLimit", index);
packet.ReadInt32("Unk 4", index);
packet.ReadInt32("completedEncounters", index);
packet.ReadByte("Call to Arms eligible", index);
// LFG_SLOT_INFO_LOOT related
for (var i = 0; i < 3; ++i)
{
var unk1 = packet.ReadInt32E <LfgRoleFlag>("Call to Arms Role", index, i);
if (unk1 != 0)
{
packet.ReadInt32("Call to Arms Money", index, i);
packet.ReadInt32("Call to Arms XP", index, i);
var unk4 = packet.ReadByte("Call to Arms Item Count", index, i);
for (var j = 0; j < unk4; ++j)
{
packet.ReadInt32 <ItemId>("Call to Arms Item Or Currency Id", index, i, j);
packet.ReadInt32("Call to Arms Item Display ID", index, i, j);
packet.ReadInt32("Call to Arms Item Stack Count", index, i, j);
packet.ReadBool("Call to Arms Is Currency", index, i, j);
}
}
}
}
packet.ReadInt32("Base Money", index);
packet.ReadInt32("Base XP", index);
if (ClientVersion.RemovedInVersion(ClientVersionBuild.V4_0_6a_13623))
{
packet.ReadInt32("Variable Money", index);
packet.ReadInt32("Variable XP", index);
}
var numFields = packet.ReadByte("Reward Item Count", index);
for (var i = 0; i < numFields; i++)
{
packet.ReadInt32 <ItemId>("Reward Item Or Currency Id", index, i);
packet.ReadInt32("Reward Item Display ID", index, i);
packet.ReadInt32("Reward Item Stack Count", index, i);
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_0_6a_13623))
{
packet.ReadBool("Is Currency", index, i);
}
}
}
public static void ReadSpellCastData(Packet packet, params object[] idx)
{
bool isSpellGo = packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_SPELL_GO, Direction.ServerToClient);
WowGuid targetGUID = new WowGuid64();
var casterGUID = packet.ReadPackedGuid("CasterGUID", idx);
packet.ReadPackedGuid("CasterUnit", idx);
packet.ReadByte("CastID", idx);
var spellId = packet.ReadInt32 <SpellId>("SpellID", idx);
CastFlag flags = packet.ReadInt32E <CastFlag>("CastFlags", idx);
packet.ReadUInt32("CastFlagsEx", idx);
packet.ReadUInt32("CastTime", idx);
if (isSpellGo)
{
var hitTargetsCount = packet.ReadByte("HitTargetsCount", idx);
for (var i = 0; i < hitTargetsCount; ++i)
{
packet.ReadGuid("HitTarget", idx, i);
}
var missCount = packet.ReadByte("MissStatusCount", idx);
for (var i = 0; i < missCount; ++i)
{
ReadSpellMissStatus(packet, idx, "MissStatus", i);
}
}
TargetFlag targetFlags = TargetFlag.Self;
ReadSpellTargetData(packet, ref targetFlags, targetGUID, idx, "Target");
if (flags.HasAnyFlag(CastFlag.PredictedPower))
{
packet.ReadUInt32("RemainingPower");
}
if (flags.HasAnyFlag(CastFlag.RuneInfo))
{
ReadRuneData(packet, idx, "RemainingRunes");
}
if (isSpellGo)
{
if (flags.HasAnyFlag(CastFlag.AdjustMissile))
{
ReadMissileTrajectoryResult(packet, idx, "MissileTrajectory");
}
}
if (flags.HasAnyFlag(CastFlag.Projectile))
{
ReadSpellAmmo(packet, idx, "Ammo");
}
if (isSpellGo)
{
if (flags.HasAnyFlag(CastFlag.VisualChain))
{
ReadProjectileVisual(packet, idx, "ProjectileVisual");
}
if (targetFlags.HasAnyFlag(TargetFlag.DestinationLocation))
{
packet.ReadByte("DestLocSpellCastIndex", idx);
}
if (targetFlags.HasAnyFlag(TargetFlag.ExtraTargets))
{
var targetPointsCount = packet.ReadInt32("TargetPointsCount", idx);
for (var i = 0; i < targetPointsCount; ++i)
{
ReadTargetLocation(packet, idx, "TargetPoints", i);
}
}
}
else
{
if (flags.HasAnyFlag(CastFlag.Immunity))
{
ReadCreatureImmunities(packet, idx, "Immunities");
}
if (flags.HasAnyFlag(CastFlag.HealPrediction))
{
ReadSpellHealPrediction(packet, idx, "Predict");
}
}
if (flags.HasAnyFlag(CastFlag.Unknown21) && !isSpellGo)
{
NpcSpellClick spellClick = new NpcSpellClick
{
SpellID = (uint)spellId,
CasterGUID = casterGUID,
TargetGUID = targetGUID
};
Storage.SpellClicks.Add(spellClick, packet.TimeSpan);
}
if (isSpellGo)
{
packet.AddSniffData(StoreNameType.Spell, spellId, "SPELL_GO");
}
}
