public static void FindNoLoginCharacterGUID()
{
Dictionary <uint, int> possibleGUIDs = new Dictionary <uint, int>();
bool previousIsMoveToState = false;
if (Records.Count > 0)
{
foreach (var record in Records)
{
try
{
if (record.data.Length <= 4)
{
continue;
}
using (BinaryReader fragDataReader = new BinaryReader(new MemoryStream(record.data)))
{
PacketOpcode opcode = Util.readOpcode(fragDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Movement__MoveToState_ID:
previousIsMoveToState = true;
break;
case PacketOpcode.Evt_Movement__MovementEvent_ID:
if (previousIsMoveToState)
{
// fragDataReader.BaseStream.Position += 4;
uint guid = fragDataReader.ReadUInt32();
if (possibleGUIDs.ContainsKey(guid))
{
possibleGUIDs[guid]++;
}
else
{
possibleGUIDs.Add(guid, 1);
}
}
break;
default:
previousIsMoveToState = false;
break;
}
}
}
catch
{
// Do something with the exception maybe
}
}
}
if (possibleGUIDs.Count > 0)
{
// Set to the most frequent result. This should usually be the character.
CharacterGUID = possibleGUIDs.FirstOrDefault(x => x.Value == possibleGUIDs.Values.Max()).Key;
}
}
/// <summary>
/// Search through the loaded pcap to find the first instance of a position.
/// We'll use that position to set the initial player location for the no-login pcap.
/// </summary>
public static void GetPlayerStartingPosition()
{
if (Records.Count > 0)
{
foreach (var record in Records)
{
try
{
if (record.data.Length <= 4)
{
continue;
}
using (BinaryReader fragDataReader = new BinaryReader(new MemoryStream(record.data)))
{
PacketOpcode opcode = Util.readOpcode(fragDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Movement__UpdatePosition_ID:
if (ReadUpdatePosition(fragDataReader))
{
return;
}
break;
}
}
}
catch
{
// Do something with the exception maybe
}
}
}
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Vendor__Buy_ID: {
Buy message = Buy.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Vendor__Sell_ID: {
Sell message = Sell.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: PacketOpcode.Evt_Vendor__RequestVendorInfo_ID
// TODO: PacketOpcode.VENDOR_INFO_EVENT:
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Misc__PortalStorm_ID:
case PacketOpcode.Evt_Misc__PortalStormSubsided_ID: {
EmptyMessage message = new EmptyMessage(opcode);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Misc__PortalStormBrewing_ID: {
PortalStormBrewing message = PortalStormBrewing.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Misc__PortalStormImminent_ID: {
PortalStormImminent message = PortalStormImminent.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
// TODO: PacketOpcode.Evt_Advocate__Bestow_ID
// TODO: PacketOpcode.Evt_Advocate__SetState_ID
// TODO: PacketOpcode.Evt_Advocate__SetAttackable_ID
case PacketOpcode.Evt_Advocate__Teleport_ID: {
Teleport message = Teleport.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: PacketOpcode.Evt_Advocate__TeleportTo_ID
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Login__CharacterSet_ID: {
Login__CharacterSet message = Login__CharacterSet.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Login__WorldInfo_ID: {
WorldInfo message = WorldInfo.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.PLAYER_DESCRIPTION_EVENT:
{
PlayerDescription message = PlayerDescription.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Communication__Recv_ChatRoomTracker_ID:
{
ChatRoomTracker message = ChatRoomTracker.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Communication__WeenieError_ID: {
WeenieError message = WeenieError.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Communication__WeenieErrorWithString_ID: {
WeenieErrorWithString message = WeenieErrorWithString.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public static PacketOpcode readUnorderedOpcode(BinaryReader fragDataReader)
{
PacketOpcode opcode = 0;
opcode = (PacketOpcode)fragDataReader.ReadUInt32();
return(opcode);
}
private void UpdateInt(BinaryReader messageDataReader, PacketOpcode opcode)
{
CM_Qualities.UpdateQualityEvent <STypeInt, int> message = CM_Qualities.UpdateQualityEvent <STypeInt, int> .read(opcode, messageDataReader);
if (message.sender == character.ID)
{
character.PKStatus = (PKStatusEnum)message.val;
}
}
public static PrivateRemoveQualityEvent <TSType> read(PacketOpcode opcode, BinaryReader binaryReader)
{
var newObj = new PrivateRemoveQualityEvent <TSType>();
newObj.opcode = opcode;
newObj.wts = binaryReader.ReadByte();
newObj.stype = (TSType)Enum.ToObject(typeof(TSType), binaryReader.ReadUInt32());
return(newObj);
}
private void UpdatePrivateInt(BinaryReader messageDataReader, PacketOpcode opcode)
{
CM_Qualities.PrivateUpdateQualityEvent <STypeInt, int> message = CM_Qualities.PrivateUpdateQualityEvent <STypeInt, int> .read(opcode, messageDataReader);
if (message.stype == STypeInt.LEVEL_INT)
{
character.Level = message.val;
}
}
public static PrivateUpdateQualityEvent <TSType, T> read(PacketOpcode opcode, BinaryReader binaryReader)
{
PrivateUpdateQualityEvent <TSType, T> newObj = new PrivateUpdateQualityEvent <TSType, T>();
newObj.opcode = opcode;
newObj.wts = binaryReader.ReadByte();
newObj.stype = (TSType)Enum.ToObject(typeof(TSType), binaryReader.ReadUInt32());
newObj.val = Util.readers[typeof(T)](binaryReader);
return(newObj);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Combat__CancelAttack_ID:
case PacketOpcode.Evt_Combat__CommenceAttack_ID: {
EmptyMessage message = new EmptyMessage(opcode);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: Evt_Combat__UntargetedMeleeAttack_ID
case PacketOpcode.Evt_Combat__TargetedMeleeAttack_ID: {
TargetedMeleeAttack message = TargetedMeleeAttack.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Combat__TargetedMissileAttack_ID: {
TargetedMissileAttack message = TargetedMissileAttack.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: Evt_Combat__UntargetedMissileAttack_ID
case PacketOpcode.Evt_Combat__ChangeCombatMode_ID: {
ChangeCombatMode message = ChangeCombatMode.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Combat__QueryHealth_ID: {
QueryHealth message = QueryHealth.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Combat__QueryHealthResponse_ID: {
QueryHealthResponse message = QueryHealthResponse.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public static RawNetPacket[] GetRawPacketFromOpcode(PacketOpcode op, Dictionary <string, object> bundledData = null)
{
if (!PacketOpcodeLookupTable.ContainsKey(op))
{
throw new NotSupportedException($"{op.ToString()} does not have an associated packet constructor.");
}
var type = PacketOpcodeLookupTable[op];
var instance = (IPacketConstructor)Activator.CreateInstance(type);
return(bundledData == null?instance.ConstructPacket() : instance.ConstructPacket(bundledData));
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
// TODO: Add all BOOK_*_RESPONSE_EVENT
case PacketOpcode.Evt_Writing__BookData_ID: {
BookData message = BookData.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Writing__BookModifyPage_ID: {
BookModifyPage message = BookModifyPage.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Writing__BookAddPage_ID: {
BookAddPage message = BookAddPage.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Writing__BookDeletePage_ID: {
BookDeletePage message = BookDeletePage.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Writing__BookPageData_ID: {
BookPageData message = BookPageData.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: Evt_Writing__GetInscription_ID
case PacketOpcode.Evt_Writing__SetInscription_ID: {
SetInscription message = SetInscription.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public static PrivateUpdateStringEvent read(PacketOpcode opcode, BinaryReader binaryReader)
{
var newObj = new PrivateUpdateStringEvent();
newObj.opcode = opcode;
newObj.wts = binaryReader.ReadByte();
newObj.stype = (STypeString)binaryReader.ReadUInt32();
newObj.padding = Util.readToAlign(binaryReader);
newObj.val = PStringChar.read(binaryReader);
return(newObj);
}
public static PrivateUpdateQualityEvent <TSType, T> read(PacketOpcode opcode, BinaryReader binaryReader)
{
var newObj = new PrivateUpdateQualityEvent <TSType, T>();
newObj.opcode = opcode;
newObj.wts = binaryReader.ReadByte();
newObj.stype = (TSType)Enum.ToObject(typeof(TSType), binaryReader.ReadUInt32());
var valStartPosition = binaryReader.BaseStream.Position;
newObj.val = Util.readers[typeof(T)](binaryReader);
newObj.valLength = (int)(binaryReader.BaseStream.Position - valStartPosition);
return(newObj);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Game__Join_ID:
{
Join message = Join.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Quit_ID:
{
EmptyMessage message = new EmptyMessage(opcode);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Stalemate_ID:
{
Stalemate message = Stalemate.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Recv_JoinGameResponse_ID:
{
Recv_JoinGameResponse message = Recv_JoinGameResponse.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Recv_GameOver_ID:
{
Recv_GameOver message = Recv_GameOver.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
private void updateTree()
{
treeView_ParsedData.Nodes.Clear();
if (listView_Packets.SelectedIndices.Count > 0)
{
PacketRecord record = records[Int32.Parse(listItems[listView_Packets.SelectedIndices[0]].SubItems[0].Text)];
foreach (BlobFrag frag in record.netPacket.fragList_)
{
BinaryReader fragDataReader = new BinaryReader(new MemoryStream(frag.dat_));
try
{
bool handled = false;
foreach (MessageProcessor messageProcessor in messageProcessors)
{
long readerStartPos = fragDataReader.BaseStream.Position;
bool accepted = messageProcessor.acceptMessageData(fragDataReader, treeView_ParsedData);
if (accepted && handled)
{
throw new Exception("Multiple message processors are handling the same data!");
}
if (accepted)
{
handled = true;
if (fragDataReader.BaseStream.Position != fragDataReader.BaseStream.Length)
{
treeView_ParsedData.Nodes.Add(new TreeNode("WARNING: Prev fragment not fully read!"));
}
}
fragDataReader.BaseStream.Position = readerStartPos;
}
if (!handled)
{
PacketOpcode opcode = Util.readOpcode(fragDataReader);
treeView_ParsedData.Nodes.Add(new TreeNode("Unhandled: " + opcode));
}
}
catch (Exception e)
{
treeView_ParsedData.Nodes.Add(new TreeNode("EXCEPTION: " + e.Message));
}
}
}
}
public static PacketOpcode readOrderedOpcode(BinaryReader fragDataReader, ref uint id)
{
PacketOpcode opcode = 0;
opcode = (PacketOpcode)fragDataReader.ReadUInt32();
if (opcode == PacketOpcode.WEENIE_ORDERED_EVENT)
{
WOrderHdr orderHeader = WOrderHdr.read(fragDataReader);
id = orderHeader.id;
opcode = (PacketOpcode)fragDataReader.ReadUInt32();
}
return(opcode);
}
// find login descriptions followed by deaths of the logged in character
private List <Tuple <int, int, uint> > FindDeaths()
{
uint characterID = uint.MaxValue;
uint loginCharacterID = 0x0;
List <Tuple <int, int, uint> > deathRecords = new List <Tuple <int, int, uint> >();
int startRecord = -1;
for (int i = 0; i < records.Count; i++)
{
using (BinaryReader messageDataReader = new BinaryReader(new MemoryStream(records[i].data)))
{
PacketOpcode opcode = Util.readOrderedOpcode(messageDataReader, ref characterID);
switch (opcode)
{
case PacketOpcode.CHARACTER_ENTER_GAME_EVENT:
{
Proto_UI.EnterWorld message = Proto_UI.EnterWorld.read(messageDataReader);
startRecord = i;
break;
}
case PacketOpcode.PLAYER_DESCRIPTION_EVENT:
{
CM_Login.PlayerDescription message = CM_Login.PlayerDescription.read(messageDataReader);
if ((uint)message.CACQualities._weenie_type == 43480 || (uint)message.CACQualities._weenie_type == 43481)
{
// exclude Olthoi play
continue;
}
loginCharacterID = characterID;
break;
}
case PacketOpcode.VICTIM_NOTIFICATION_EVENT:
{
// we have a player descrption event for this death
if (characterID == loginCharacterID)
{
deathRecords.Add(new Tuple <int, int, uint>(startRecord, i, loginCharacterID));
}
break;
}
}
}
}
return(deathRecords);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Item__Appraise_ID: {
Appraise message = Appraise.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Item__UseDone_ID: {
UseDone message = UseDone.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Item__AppraiseDone_ID:
{
AppraiseDone message = AppraiseDone.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Item__QueryItemMana_ID: {
QueryItemMana message = QueryItemMana.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Item__QueryItemManaResponse_ID: {
QueryItemManaResponse message = QueryItemManaResponse.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Vendor__Buy_ID: {
Buy message = Buy.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Vendor__Sell_ID:
{
Sell message = Sell.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// (I could find no instance of this event in logs. Possibly a retired event? - OptimShi)
case PacketOpcode.Evt_Vendor__RequestVendorInfo_ID: {
handled = false;
break;
}
case PacketOpcode.VENDOR_INFO_EVENT:
{
gmVendorUI message = gmVendorUI.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Train__TrainAttribute2nd_ID: {
TrainAttribute2nd message = TrainAttribute2nd.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Train__TrainAttribute_ID: {
TrainAttribute message = TrainAttribute.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Train__TrainSkill_ID: {
TrainSkill message = TrainSkill.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Train__TrainSkillAdvancementClass_ID: {
TrainSkillAdvancementClass message = TrainSkillAdvancementClass.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.APPRAISAL_INFO_EVENT: {
SetAppraiseInfo message = SetAppraiseInfo.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.PLAYER_DEATH_EVENT:
{
PlayerDeathEvent message = PlayerDeathEvent.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.VICTIM_NOTIFICATION_EVENT:
{
VictimDeathNotice message = VictimDeathNotice.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.KILLER_NOTIFICATION_EVENT:
{
KillerDeathNotice message = KillerDeathNotice.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default:
{
handled = false;
break;
}
}
return(handled);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Admin__ChatServerData_ID: // 0xF7DE
{
var message = ChatServerData.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
private void readPacket(PacketRecord packet, StringBuilder packetTypeStr, BinaryReader packetReader)
{
BlobFrag newFrag = new BlobFrag();
newFrag.memberHeader_ = BlobFragHeader_t.read(packetReader);
newFrag.dat_ = packetReader.ReadBytes(newFrag.memberHeader_.blobFragSize - 16); // 16 == size of frag header
packet.netPacket.fragList_.Add(newFrag);
BinaryReader fragDataReader = new BinaryReader(new MemoryStream(newFrag.dat_));
if (newFrag.memberHeader_.blobNum != 0)
{
packetTypeStr.Append("FragData[");
packetTypeStr.Append(newFrag.memberHeader_.blobNum);
packetTypeStr.Append("]");
}
else
{
PacketOpcode opcode = Util.readOpcode(fragDataReader);
packet.opcodes.Add(opcode);
packetTypeStr.Append(opcode.ToString());
}
}
private void UpdateInstanceID(BinaryReader messageDataReader, PacketOpcode opcode)
{
CM_Qualities.UpdateQualityEvent <STypeIID, uint> message = CM_Qualities.UpdateQualityEvent <STypeIID, uint> .read(opcode, messageDataReader);
if (message.stype == STypeIID.CONTAINER_IID)
{
uint id = message.sender;
uint containerId = message.val;
if (character.Contains(containerId))
{
Item item;
if (character.FindItem(id, out item))
{
item.ContainerID = containerId;
character.UpdateItem(item);
}
else if (otherObjects.TryGetValue(id, out item))
{
character.AddItemToContainer(item, containerId);
otherObjects.Remove(id);
}
else
{
Debug.Assert(false);
}
}
}
else if (message.stype == STypeIID.WIELDER_IID)
{
Item item;
if (character.FindItem(message.sender, out item))
{
item.WielderID = message.val;
}
}
}
