/// <summary> /// /// </summary> /// <param name="gr"></param> /// <param name="gr2"></param> /// <param name="sb"></param> /// <param name="swe"></param> /// <returns></returns> public static bool ParseInitialSpellsOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset " + gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_INITIAL_SPELLS (0x012A)"); byte unk1 = gr2.ReadByte(); sb.AppendLine("unk byte " + unk1); ushort spells_count = gr2.ReadUInt16(); sb.AppendLine("Spells count " + spells_count); for (ushort i = 0; i < spells_count; i++) { ushort spellid = gr2.ReadUInt16(); ushort slotid = gr2.ReadUInt16(); sb.AppendLine("Spell ID " + spellid + ", slot " + slotid.ToString("X2")); } ushort cooldowns_count = gr2.ReadUInt16(); sb.AppendLine("Cooldowns count " + cooldowns_count); for (ushort i = 0; i < cooldowns_count; i++) { ushort spellid = gr2.ReadUInt16(); ushort itemid = gr2.ReadUInt16(); ushort spellcategory = gr2.ReadUInt16(); uint cooldown1 = gr2.ReadUInt32(); uint cooldown2 = gr2.ReadUInt32(); sb.AppendLine("Spell Cooldown: spell id " + spellid + ", itemid " + itemid + ", spellcategory " + spellcategory + ", cooldown1 " + cooldown1 + ", cooldown2 " + cooldown2); } return(true); }
public readonly Vector2 UVCoordinates; // UV coordinates. public SiPoint(GenericReader r) { Point = r.ReadUInt32(); PointOffset = r.ReadUInt32(); Normal = r.ReadVector3(); UVCoordinates = r.ReadVector2(); }
public uint miscFlags2; // see DDS_MISC_FLAGS2 public void Read(GenericReader r) { dxgiFormat = (DXGIFormat)r.ReadInt32(); resourceDimension = (DDSDimension)r.ReadUInt32(); miscFlag = r.ReadUInt32(); arraySize = r.ReadUInt32(); miscFlags2 = r.ReadUInt32(); }
public SiAnimationPart(GenericReader r) { _bs = r.BaseStream; _bsp = _bs.Position; Id = r.ReadUInt32(); Name = ""; FrameCount = r.ReadUInt32(); Frames = new SiAnimationFrame[FrameCount]; for (var i = 0; i < Frames.Length; i++) { Frames[i] = new SiAnimationFrame(r); } }
public SiMesh(GenericReader r) { LimbId = r.ReadUInt32(); ParentId = r.ReadUInt32(); ScaleX = r.ReadUInt32(); ScaleY = r.ReadUInt32(); ScaleZ = r.ReadUInt32(); Position = r.ReadVector3(); OrientationW = r.ReadSingle(); OrientationX = r.ReadSingle(); OrientationY = r.ReadSingle(); OrientationZ = r.ReadSingle(); Lod = new SiMeshLod(r); }
public static bool ParseLoginSetTimeSpeedOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset " + gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_LOGIN_SETTIMESPEED (0x0042)"); StreamWriter sw = new StreamWriter("login_timespeed.log", true, Encoding.ASCII); uint time = gr2.ReadUInt32(); float speed = gr2.ReadSingle(); sw.WriteLine("time {0}, speed {1}", time, speed); sw.Flush(); sw.Close(); if (gr2.BaseStream.Position == gr2.BaseStream.Length) { sb.AppendLine("parsed: ok..."); } else { sb.AppendLine("parsed: error..."); } return(true); }
public SiAnimationFrame(GenericReader r) { _bs = r.BaseStream; _bsp = _bs.Position; Ms = r.ReadUInt32(); Position = r.ReadVector3(); Unknown1 = r.ReadVector4(); Scale = r.ReadVector3(); }
public static bool ParseLoginVerifyWorldOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { // used to get current map id uint mapid = gr2.ReadUInt32(); Coords4 coords = gr2.ReadCoords4(); MapId = mapid; return(true); }
public static bool ParseCorpseQueryOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { if (direction == 0) // client packet { return(false); } StreamWriter sw = new StreamWriter("corpse_query.log", true, Encoding.ASCII); sw.WriteLine("Packet offset {0}", gr.BaseStream.Position.ToString("X2")); sw.WriteLine("Opcode MSG_CORPSE_QUERY (0x0216)"); byte unk = gr2.ReadByte(); sw.WriteLine("unk {0}", unk); if (unk > 0) { uint mapid1 = gr2.ReadUInt32(); float x = gr2.ReadSingle(); float y = gr2.ReadSingle(); float z = gr2.ReadSingle(); uint mapid2 = gr2.ReadUInt32(); sw.WriteLine("map {0}, pos {1} {2} {3}", mapid1, x, y, z); sw.WriteLine("map2 {0}", mapid2); } if (gr2.BaseStream.Position == gr2.BaseStream.Length) { sw.WriteLine("parsed: ok..."); } else { sw.WriteLine("parsed: error..."); } sw.WriteLine(); sw.Flush(); sw.Close(); return(true); }
public SiFile(string name, GenericReader r) { Name = name; MeshCount = r.ReadUInt32(); LodCount = r.ReadUInt32(); CylinderBaseCentre = r.ReadVector3(); CylinderBaseHeight = r.ReadSingle(); CylinderBaseRadius = r.ReadSingle(); SphereCenter = r.ReadVector3(); SphereRadius = r.ReadSingle(); Unk1 = r.ReadSingle(); MinBounds = r.ReadVector3(); MaxBounds = r.ReadVector3(); LodThreshold0 = r.ReadUInt32(); LodThreshold1 = r.ReadUInt32(); LodThreshold2 = r.ReadUInt32(); LodThreshold3 = r.ReadUInt32(); CenterOfMass = r.ReadVector3(); MassOrVolume = r.ReadSingle(); InertiaMatrix = r.ReadRowMajorMatrix3x3(); InertiaRelated = r.ReadSingle(); // var meshCount = (int)(MeshCount * LodCount); var meshOffset = r.ReadTArray <uint>(meshCount * 4, meshCount); Meshes = new SiMesh[meshCount]; for (var i = 0; i < meshOffset.Length; i++) { r.Position = meshOffset[i]; Meshes[i] = new SiMesh(r); } }
public SiAnimation(GenericReader r) { _bs = r.BaseStream; _bsp = _bs.Position; Index = r.ReadUInt32(); Unknown1 = r.ReadUInt32(); TotalFrameCount = r.ReadUInt32(); Unknown2 = r.ReadUInt32(); Filename = null; HeaderLength = r.ReadUInt32(); Unknown3 = r.ReadUInt32(); PartCount = r.ReadUInt32(); Parts = new SiAnimationPart[PartCount]; for (var i = 0; i < Parts.Length; i++) { Parts[i] = new SiAnimationPart(r); } SuffixCount = r.ReadUInt32(); Suffixes = new Vector3Int[SuffixCount]; for (var i = 0; i < Suffixes.Length; i++) { Suffixes[i] = new Vector3Int((int)r.ReadUInt32(), (int)r.ReadUInt32(), (int)r.ReadUInt32()); } }
public override void Deserialize(GenericReader reader) { base.Deserialize(reader); int version = reader.ReadInt32(); switch (version) { case 0: { m_LockdownData = reader.ReadUInt32(); break; } } }
public readonly uint[] CollisionRelated = new uint[2]; // for collision system (index list [so only values from 0, 1, or 2] that contains the index of the vertex that is closest to each of the faces [order is: left,right,front,back,bottom,top] public SiFace(GenericReader r) { Points = new[] { new SiPoint(r), new SiPoint(r), new SiPoint(r) }; Flags = r.ReadUInt32(); Flags2 = r.ReadUInt32(); NormalVector = r.ReadVector3(); VectorW = r.ReadSingle(); Material = r.ReadUInt32(); Color = r.ReadUInt32(); CollisionRelated[0] = r.ReadUInt32(); CollisionRelated[1] = r.ReadUInt32(); }
public DDSPixelFormat(GenericReader r) { var size = r.ReadUInt32(); if (size != 32) { throw new FileFormatException($"Invalid DDS file pixel format size: {size}."); } dwFlags = (DDSPixelFormats)r.ReadUInt32(); dwFourCC = r.ReadBytes(4); dwRGBBitCount = r.ReadUInt32(); dwRBitMask = r.ReadUInt32(); dwGBitMask = r.ReadUInt32(); dwBBitMask = r.ReadUInt32(); dwABitMask = r.ReadUInt32(); }
public readonly uint AnimationTimerRelated; // Animation timer value public SiMaterial(GenericReader r) { TextureId = r.ReadUInt16(); Flags = r.ReadUInt16(); SubtextureCount = r.ReadUInt16(); Flags2 = r.ReadUInt16(); FirstFaceId = r.ReadUInt16(); FaceCount = r.ReadUInt16(); DefaultAlpha = r.ReadByte(); ModifiedAlpha = r.ReadByte(); AnimationStart = r.ReadByte(); AnimationEnd = r.ReadByte(); CurFrame = r.ReadByte(); AnimationSpeed = r.ReadByte(); AnimationType = r.ReadByte(); PlaybackDirection = r.ReadByte(); AnimationTimerRelated = r.ReadUInt32(); }
public static void ParseUpdatePacket(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe) { string database_log = "data.txt"; StreamWriter data2 = new StreamWriter(database_log, true); data2.AutoFlush = true; sb.AppendLine("Packet offset " + (gr.BaseStream.Position - 2).ToString("X2")); //sb.AppendLine("Packet number: " + packet); uint count = gr2.ReadUInt32(); sb.AppendLine("Object count: " + count); uint unk = gr2.ReadByte(); sb.AppendLine("HasTransport: " + unk); for (uint i = 1; i < count + 1; i++) { sb.AppendLine("Update block for object " + i + ":"); sb.AppendLine("Block offset " + gr.BaseStream.Position.ToString("X2")); if (!ParseBlock(gr2, sb, swe, data2)) { break; } } if (gr2.BaseStream.Position == gr2.BaseStream.Length) { sb.AppendLine("packet parse: OK..."); } else { sb.AppendLine("packet parse: ERROR!"); } data2.Flush(); data2.Close(); }
private static void ReadAndDumpField(UpdateField uf, StringBuilder sb, GenericReader gr, UpdateTypes updatetype, StreamWriter data, WoWObject obj) { MemoryStream ms = new MemoryStream(gr.ReadBytes(4)); GenericReader gr2 = new GenericReader(ms); if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) { obj.SetUInt32Value(uf.Identifier, gr2.ReadUInt32()); gr2.BaseStream.Position -= 4; } switch (uf.Type) { // TODO: add data writing /*case 3: * string val1 = gr.ReadSingle().ToString().Replace(",", "."); * if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) * data.WriteLine(uf.Name + " (" + uf.Identifier + "): " + val1); * sb.AppendLine(uf.Name + " (" + index + "): " + val1); * break; * default: * uint val2 = gr.ReadUInt32(); * if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) * data.WriteLine(uf.Name + " (" + uf.Identifier + "): " + val2); * sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + val2); * break;*/ case 1: // uint32 sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr2.ReadUInt32().ToString("X8")); break; case 2: // uint16+uint16 ushort value1 = gr2.ReadUInt16(); ushort value2 = gr2.ReadUInt16(); sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + "first " + value1.ToString("X4") + ", second " + value2.ToString("X4")); if (uf.Name.StartsWith("PLAYER_SKILL_INFO_1_")) { int num = uf.Identifier - 858; if ((num % 3) == 0) { ushort skill = value1; ushort flag = value2; string str = String.Format("skill {0}, flag {1}", skill, (ProfessionFlags)flag); sb.AppendLine(str); } else if (((num - 1) % 3) == 0) { ushort minskill = value1; ushort maxskill = value2; string str = String.Format("minskill {0}, maxskill {1}", minskill, maxskill); sb.AppendLine(str); } else { ushort minbonus = value1; ushort maxbonus = value2; string str = String.Format("minbonus {0}, maxbonus {1}", minbonus, maxbonus); sb.AppendLine(str); } } break; case 3: // float sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr2.ReadSingle()); //sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr.ReadSingle().ToString().Replace(",", ".")); break; case 4: // uint64 (can be only low part) sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr2.ReadUInt32().ToString("X8")); break; case 5: // bytes uint value = gr2.ReadUInt32(); sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + value.ToString("X8")); if (uf.Identifier == 36) // UNIT_FIELD_BYTES_0 { byte[] bytes = BitConverter.GetBytes(value); Races race = (Races)bytes[0]; Class class_ = (Class)bytes[1]; Gender gender = (Gender)bytes[2]; Powers powertype = (Powers)bytes[3]; string str = String.Format("Race: {0}, class: {1}, gender: {2}, powertype: {3}", race, class_, gender, powertype); sb.AppendLine(str); } break; default: sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + "unknown type " + gr2.ReadUInt32().ToString("X8")); break; } gr2.Close(); }
private static bool ParseMovementUpdateBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data, ObjectTypes objectTypeId, WoWObject obj) { Coords4 coords; coords.X = 0; coords.Y = 0; coords.Z = 0; coords.O = 0; sb.AppendLine("=== movement_update_block_start ==="); MovementFlags mf = MovementFlags.MOVEMENTFLAG_NONE; // movement flags UpdateFlags flags = (UpdateFlags)gr.ReadByte(); sb.AppendLine("Update Flags: " + flags.ToString("X") + " : " + flags); if ((UpdateFlags.UPDATEFLAG_LIVING & flags) != 0) // 0x20 { mf = (MovementFlags)gr.ReadUInt32(); sb.AppendLine("Movement Flags: " + mf.ToString("X") + " : " + mf); byte unk = gr.ReadByte(); sb.AppendLine("Unknown Byte: " + unk.ToString("X2")); uint time = gr.ReadUInt32(); sb.AppendLine("Time: " + time.ToString("X8")); } if ((UpdateFlags.UPDATEFLAG_HASPOSITION & flags) != 0) // 0x40 { coords = gr.ReadCoords4(); sb.AppendLine("Coords: " + coords.GetCoordsAsString()); if (objectTypeId == ObjectTypes.TYPEID_UNIT || objectTypeId == ObjectTypes.TYPEID_GAMEOBJECT) { if (obj != null) { obj.SetPosition(coords.X, coords.Y, coords.Z, coords.O); } } } if ((flags & UpdateFlags.UPDATEFLAG_LIVING) != 0) // 0x20 { /*if (objectTypeId == ObjectTypes.TYPEID_UNIT || objectTypeId == ObjectTypes.TYPEID_GAMEOBJECT) * { * data.WriteLine(); * data.WriteLine(objectTypeId + ": " + coords.GetCoordsAsString()); * }*/ if ((mf & MovementFlags.MOVEMENTFLAG_ONTRANSPORT) != 0) // transport { ulong t_guid = gr.ReadUInt64(); sb.Append("Transport GUID: " + t_guid.ToString("X16") + ", "); Coords4 transport = gr.ReadCoords4(); sb.AppendLine("Transport Coords: " + transport.GetCoordsAsString()); uint unk2 = gr.ReadUInt32(); // unk, probably timestamp sb.AppendLine("Transport Unk: " + unk2.ToString("X8")); } if ((mf & (MovementFlags.MOVEMENTFLAG_SWIMMING | MovementFlags.MOVEMENTFLAG_UNK5)) != 0) { float unkf1 = gr.ReadSingle(); sb.AppendLine("MovementFlags & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_UNK5): " + unkf1); } uint unk1 = gr.ReadUInt32(); sb.AppendLine("Unk1: " + unk1.ToString("X8")); if ((mf & MovementFlags.MOVEMENTFLAG_JUMPING) != 0) { // looks like orientation/coords/speed float unk3 = gr.ReadSingle(); sb.AppendLine("unk3: " + unk3); float unk4 = gr.ReadSingle(); sb.AppendLine("unk4: " + unk4); float unk5 = gr.ReadSingle(); sb.AppendLine("unk5: " + unk5); float unk6 = gr.ReadSingle(); sb.AppendLine("unk6: " + unk6); } if ((mf & MovementFlags.MOVEMENTFLAG_SPLINE) != 0) { float unkf2 = gr.ReadSingle(); sb.AppendLine("MovementFlags & MOVEMENTFLAG_SPLINE: " + unkf2); } float ws = gr.ReadSingle(); sb.AppendLine("Walk speed: " + ws); float rs = gr.ReadSingle(); sb.AppendLine("Run speed: " + rs); float sbs = gr.ReadSingle(); sb.AppendLine("Swimback speed: " + sbs); float ss = gr.ReadSingle(); sb.AppendLine("Swim speed: " + ss); float wbs = gr.ReadSingle(); sb.AppendLine("Walkback speed: " + wbs); float fs = gr.ReadSingle(); sb.AppendLine("Fly speed: " + fs); float fbs = gr.ReadSingle(); sb.AppendLine("Flyback speed: " + fbs); float ts = gr.ReadSingle(); sb.AppendLine("Turn speed: " + ts); // pi = 3.14 if ((mf & MovementFlags.MOVEMENTFLAG_SPLINE2) != 0) { uint flags3 = gr.ReadUInt32(); sb.AppendLine("SplineFlags " + flags3.ToString("X8")); if ((flags3 & 0x10000) != 0) { Coords3 c = gr.ReadCoords3(); sb.AppendLine("SplineFlags & 0x10000: " + c.GetCoords()); } if ((flags3 & 0x20000) != 0) { ulong g3 = gr.ReadUInt64(); sb.AppendLine("flags3_guid: " + g3.ToString("X16")); // ???? } if ((flags3 & 0x40000) != 0) { uint f3_3 = gr.ReadUInt32(); sb.AppendLine("flags3_unk_value3: " + f3_3.ToString("X8")); } uint t1 = gr.ReadUInt32(); sb.AppendLine("curr tick: " + t1.ToString("X8")); uint t2 = gr.ReadUInt32(); sb.AppendLine("last tick: " + t2.ToString("X8")); uint t3 = gr.ReadUInt32(); sb.AppendLine("tick count " + t3.ToString("X8")); uint coords_count = gr.ReadUInt32(); sb.AppendLine("coords_count: " + coords_count.ToString("X8")); for (uint i = 0; i < coords_count; i++) { Coords3 v = gr.ReadCoords3(); sb.AppendLine("coord" + i + ": " + v.GetCoords()); } Coords3 end = gr.ReadCoords3(); sb.AppendLine("end: " + end.GetCoords()); } } if ((flags & UpdateFlags.UPDATEFLAG_LOWGUID) != 0) // 0x08 { uint temp = gr.ReadUInt32(); // timestamp or something like it sb.AppendLine("UpdateFlags & 0x08 (lowguid): " + temp.ToString("X8")); } if ((UpdateFlags.UPDATEFLAG_HIGHGUID & flags) != 0) // 0x10 { uint guid_high = gr.ReadUInt32(); // timestamp or something like it sb.AppendLine("UpdateFlags & 0x10 (highguid): " + guid_high.ToString("X8")); } if ((UpdateFlags.UPDATEFLAG_FULLGUID & flags) != 0) // 0x04 { ulong guid2 = gr.ReadPackedGuid(); // guid, but what guid? sb.AppendLine("UpdateFlags & 0x04 guid: " + guid2.ToString("X16")); } if ((UpdateFlags.UPDATEFLAG_TRANSPORT & flags) != 0) // 0x02 { uint time = gr.ReadUInt32(); // time sb.AppendLine("UpdateFlags & 0x02 t_time: " + time.ToString("X8")); } if ((UpdateFlags.UPDATEFLAG_SELFTARGET & flags) != 0) // 0x01 { sb.AppendLine("updating self!"); } sb.AppendLine("=== movement_update_block_end ==="); return(true); }
public static bool ParseTrainerListOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset " + gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_TRAINER_LIST (0x01B1)"); StreamWriter sw = new StreamWriter("trainer.log", true, Encoding.ASCII); ulong guid = gr2.ReadUInt64(); TrainerType trainer_type = (TrainerType)gr2.ReadUInt32(); uint spells_count = gr2.ReadUInt32(); sw.WriteLine("Trainer {0}, type {1}, spells_count {2}", guid.ToString("X16"), trainer_type, spells_count); for (uint i = 0; i < spells_count; i++) { uint spellid = gr2.ReadUInt32(); TrainerSpellState state = (TrainerSpellState)gr2.ReadByte(); uint spellcost = gr2.ReadUInt32(); uint unk1 = gr2.ReadUInt32(); // isProfession? uint unk2 = gr2.ReadUInt32(); byte reqlevel = gr2.ReadByte(); uint reqskill = gr2.ReadUInt32(); uint reqskillvalue = gr2.ReadUInt32(); uint reqspell = gr2.ReadUInt32(); uint unk3 = gr2.ReadUInt32(); uint unk4 = gr2.ReadUInt32(); sw.WriteLine("Spell {0}, state {1}, cost {2}, unk1 {3}, unk2 {4}, reqlevel {5}, reqskill {6}, reqskillvalue {7}, reqspell {8}, unk3 {9} unk4 {10}", spellid, state, spellcost, unk1, unk2, reqlevel, reqskill, reqskillvalue, reqspell, unk3, unk4); } string title = gr2.ReadStringNull(); sw.WriteLine("title {0}", title); sw.Flush(); sw.Close(); if (gr2.BaseStream.Position == gr2.BaseStream.Length) { sb.AppendLine("parsed: ok..."); } else { sb.AppendLine("parsed: error..."); } return(true); }
public override void Deserialize( GenericReader reader ) { base.Deserialize( reader ); int version = reader.ReadInt32(); switch (version) { case 0: { m_LockdownData = reader.ReadUInt32(); break; } } }
public static bool ParseSpellLogExecuteOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { StreamWriter sw = new StreamWriter("SpellLogExecute.log", true, Encoding.ASCII); sw.WriteLine("Packet offset {0}", gr.BaseStream.Position.ToString("X2")); sw.WriteLine("Opcode SMSG_SPELLLOGEXECUTE (0x024C)"); ulong caster = gr2.ReadPackedGuid(); sw.WriteLine("caster {0}", caster.ToString("X16")); uint spellid = gr2.ReadUInt32(); sw.WriteLine("spellid {0}", spellid); uint count1 = gr2.ReadUInt32(); sw.WriteLine("count1 {0}", count1); for (uint i = 0; i < count1; ++i) { uint spelleffect = gr2.ReadUInt32(); sw.WriteLine("spelleffect {0}", spelleffect); uint count2 = gr2.ReadUInt32(); sw.WriteLine("count2 {0}", count2); for (uint j = 0; j < count2; ++j) { ulong guid; uint unk1; uint unk2; float unk3; switch (spelleffect) { case 0x08: // SPELL_EFFECT_MANA_DRAIN guid = gr2.ReadPackedGuid(); unk1 = gr2.ReadUInt32(); unk2 = gr2.ReadUInt32(); unk3 = gr2.ReadSingle(); sw.WriteLine("0x08: {0} {1} {2} {3}", guid.ToString("X16"), unk1, unk2, unk3); break; case 0x13: // SPELL_EFFECT_ADD_EXTRA_ATTACKS guid = gr2.ReadPackedGuid(); unk1 = gr2.ReadUInt32(); sw.WriteLine("0x13: {0} {1}", guid.ToString("X16"), unk1); break; case 0x44: // SPELL_EFFECT_INTERRUPT_CAST guid = gr2.ReadPackedGuid(); unk1 = gr2.ReadUInt32(); sw.WriteLine("0x44: {0} {1}", guid.ToString("X16"), unk1); break; case 0x6F: // SPELL_EFFECT_DURABILITY_DAMAGE guid = gr2.ReadPackedGuid(); unk1 = gr2.ReadUInt32(); unk2 = gr2.ReadUInt32(); sw.WriteLine("0x6F: {0} {1} {2}", guid.ToString("X16"), unk1, unk2); break; case 0x21: // SPELL_EFFECT_OPEN_LOCK case 0x3B: // SPELL_EFFECT_OPEN_LOCK_ITEM guid = gr2.ReadPackedGuid(); sw.WriteLine("0x21,0x3B: {0}", guid.ToString("X16")); break; case 0x18: // SPELL_EFFECT_CREATE_ITEM unk1 = gr2.ReadUInt32(); sw.WriteLine("0x18: {0}", unk1); break; case 0x1C: // SPELL_EFFECT_SUMMON case 0x29: // SPELL_EFFECT_SUMMON_WILD case 0x2A: // SPELL_EFFECT_SUMMON_GUARDIAN case 0x32: // SPELL_EFFECT_TRANS_DOOR case 0x38: // SPELL_EFFECT_SUMMON_PET case 0x49: // SPELL_EFFECT_SUMMON_POSSESSED case 0x4A: // SPELL_EFFECT_SUMMON_TOTEM case 0x4C: // SPELL_EFFECT_SUMMON_OBJECT_WILD case 0x51: // SPELL_EFFECT_CREATE_HOUSE case 0x53: // SPELL_EFFECT_DUEL case 0x57: // SPELL_EFFECT_SUMMON_TOTEM_SLOT1 case 0x58: // SPELL_EFFECT_SUMMON_TOTEM_SLOT2 case 0x59: // SPELL_EFFECT_SUMMON_TOTEM_SLOT3 case 0x5A: // SPELL_EFFECT_SUMMON_TOTEM_SLOT4 case 0x5D: // SPELL_EFFECT_SUMMON_PHANTASM case 0x61: // SPELL_EFFECT_SUMMON_CRITTER case 0x68: // SPELL_EFFECT_SUMMON_OBJECT_SLOT1 case 0x69: // SPELL_EFFECT_SUMMON_OBJECT_SLOT2 case 0x6A: // SPELL_EFFECT_SUMMON_OBJECT_SLOT3 case 0x6B: // SPELL_EFFECT_SUMMON_OBJECT_SLOT4 case 0x70: // SPELL_EFFECT_SUMMON_DEMON case 0x96: // SPELL_EFFECT_150 guid = gr2.ReadPackedGuid(); sw.WriteLine("summon: {0}", guid.ToString("X16")); break; case 0x65: // SPELL_EFFECT_FEED_PET unk1 = gr2.ReadUInt32(); sw.WriteLine("0x65: {0}", unk1); break; case 0x66: // SPELL_EFFECT_DISMISS_PET guid = gr2.ReadPackedGuid(); sw.WriteLine("0x66: {0}", guid.ToString("X16")); break; default: sw.WriteLine("unknown spell effect {0}", spelleffect); break; } } } if (gr2.BaseStream.Position != gr2.BaseStream.Length) { sw.WriteLine("F**K!"); } sw.WriteLine(); sw.Flush(); sw.Close(); return(true); }
private bool ParseMovementUpdateBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data, ObjectTypes objectTypeId) { Coords4 coords; // need figure out flags2, check flags, because we can't read packet without it... // flags2: // 0x1 - not affect data // 0x2 - need check // 0x4 // 0x8 // 0x10 - need check // 0x20 - not affect data // 0x100 // 0x800 // 0x2000 - need check // 0x4000 // 0x200000 // 0x8000000 ? // 0x10000000 // 0x20000000 sb.AppendLine("=== movement_update_block_start ==="); uint flags2 = 0; UpdateFlags flags = (UpdateFlags)gr.ReadByte(); sb.AppendLine("flags " + flags.ToString("X")); if ((UpdateFlags.UPDATEFLAG_LIVING & flags) != 0) // 0x20 { flags2 = gr.ReadUInt32(); sb.AppendLine("flags2 " + flags2.ToString("X8")); uint time = gr.ReadUInt32(); sb.AppendLine("time " + time); } if ((UpdateFlags.UPDATEFLAG_HASPOSITION & flags) != 0) // 0x40 { if ((UpdateFlags.UPDATEFLAG_TRANSPORT & flags) != 0) // 0x02 { coords = gr.ReadCoords4(); sb.AppendLine("coords " + coords.GetCoordsAsString()); } else // strange, we read the same data :) { coords = gr.ReadCoords4(); sb.AppendLine("coords " + coords.GetCoordsAsString()); } if (objectTypeId == ObjectTypes.TYPEID_UNIT || objectTypeId == ObjectTypes.TYPEID_GAMEOBJECT) { data.WriteLine(); data.WriteLine(objectTypeId + ": " + coords.GetCoordsAsString()); } if ((flags2 & 0x0200) != 0) // transport { ulong t_guid = gr.ReadUInt64(); sb.Append("t_guid " + t_guid.ToString("X2") + ", "); Coords4 transport = gr.ReadCoords4(); sb.AppendLine("t_coords " + transport.GetCoordsAsString()); uint unk1 = gr.ReadUInt32(); // unk, 2.0.6 == 0x11 or random sb.AppendLine("unk1 " + unk1); } } if ((UpdateFlags.UPDATEFLAG_LIVING & flags) != 0) // 0x20 { uint unk1 = gr.ReadUInt32(); sb.AppendLine("unk1 " + unk1); if ((flags2 & 0x2000) != 0) // <--- { // looks like orientation/coords/speed float unk2 = gr.ReadSingle(); sb.AppendLine("unk2 " + unk2); float unk3 = gr.ReadSingle(); sb.AppendLine("unk3 " + unk3); float unk4 = gr.ReadSingle(); sb.AppendLine("unk4 " + unk4); float unk5 = gr.ReadSingle(); sb.AppendLine("unk5 " + unk5); } float ws = gr.ReadSingle(); sb.AppendLine("Walk speed " + ws); float rs = gr.ReadSingle(); sb.AppendLine("Run speed " + rs); float sbs = gr.ReadSingle(); sb.AppendLine("Swimback speed " + sbs); float ss = gr.ReadSingle(); sb.AppendLine("Swim speed " + ss); float wbs = gr.ReadSingle(); sb.AppendLine("Walkback speed " + wbs); float fs = gr.ReadSingle(); sb.AppendLine("Fly speed " + fs); float fbs = gr.ReadSingle(); sb.AppendLine("Flyback speed " + fbs); float ts = gr.ReadSingle(); sb.AppendLine("Turn speed " + ts); // pi = 3.14 } // after 2.0.10 released, I can't figure out what is flags3 and when it used... uint flags3 = 0; if ((UpdateFlags.UPDATEFLAG_ALL & flags) != 0) // 0x10 { flags3 = gr.ReadUInt32(); // looks like flags (0x0, 0x1, 0x100, 0x20000, 0x40000)... sb.AppendLine("flags3 " + flags3.ToString("X2")); } /* // still used, but can't figure out when... if ((flags2 & 0x8000000) == 0 && objectTypeId == ObjectTypes.TYPEID_UNIT) { if ((flags3 & 0x40000) != 0) { uint f3_3 = br.ReadUInt32(); sb.AppendLine("flags3_unk_value3 " + f3_3); } if ((flags3 & 0x20000) != 0) { ulong g3 = br.ReadUInt64(); sb.AppendLine("flags3_guid " + g3); // ???? } } */ if ((UpdateFlags.UPDATEFLAG_HIGHGUID & flags) != 0) // 0x08 { uint guid_high = gr.ReadUInt32(); // 2.0.10 - it's not high guid anymore sb.AppendLine("guid_high " + guid_high); } if ((UpdateFlags.UPDATEFLAG_FULLGUID & flags) != 0) // 0x04 //if ((UpdateFlags.UPDATEFLAG_FULLGUID & flags) != 0 && (flags3 & 0x20000) == 0) // 0x04 //if ((UpdateFlags.UPDATEFLAG_FULLGUID & flags) != 0 && (flags3 & 0x40000) == 0) // 0x04 { //long pos = br.BaseStream.Position; //swe.WriteLine("flags & 0x4 at position " + pos.ToString("X2")); ulong guid2 = gr.ReadPackedGuid(); // looks like guid, but what guid? sb.AppendLine("unk guid " + guid2); } if ((UpdateFlags.UPDATEFLAG_TRANSPORT & flags) != 0) // 0x02 { uint time = gr.ReadUInt32(); sb.AppendLine("t_time " + time); } if ((flags2 & 0x8000000) != 0) // splines { uint t1 = gr.ReadUInt32(); sb.AppendLine("t1 " + t1); uint t2 = gr.ReadUInt32(); sb.AppendLine("t2 " + t2); //outdated 2.0.10 //uint t3 = br.ReadUInt32(); //sb.AppendLine("t3 " + t3); uint coords_count = gr.ReadUInt32(); sb.AppendLine("coords_count " + coords_count); //if (coords_count > 1000) //{ // coords_count = br.ReadUInt32(); // sb.AppendLine("second attempt to get correct coords count, now " + coords_count); //} //if (coords_count > 1000) //{ // coords_count = br.ReadUInt32(); // sb.AppendLine("third attempt to get correct coords count, now " + coords_count); //} if (coords_count > 1000) // prevent overflow in case wrong packet parsing :) { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing movement update block, flags: " + flags.ToString("X") + ", flags2: " + flags2.ToString("X") + ", flags3: " + flags3.ToString("X") + ", objecttype " + objectTypeId); return false; } if (coords_count > 0) { for (uint i = 0; i < coords_count; i++) { Coords3 v = gr.ReadCoords3(); sb.AppendLine("coord" + i + ": " + v.GetCoords()); } } Coords3 end = gr.ReadCoords3(); sb.AppendLine("end: " + end.GetCoords()); uint t8 = gr.ReadUInt32(); sb.AppendLine("t8 " + t8); // added in 2.0.10 (really?) uint t9 = gr.ReadUInt32(); sb.AppendLine("t9 " + t9); } sb.AppendLine("=== movement_update_block_end ==="); return true; }
/// <summary> /// /// </summary> /// <param name="gr"></param> /// <param name="gr2"></param> /// <param name="sb"></param> /// <param name="swe"></param> /// <returns></returns> public static bool ParseAuctionListResultOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset "); sb.AppendLine(gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_AUCTION_LIST_RESULT (0x025C)"); uint count = gr2.ReadUInt32(); sb.AppendLine("count "); sb.AppendLine(count.ToString()); for (uint i = 0; i < count; i++) { uint auction_id = gr2.ReadUInt32(); sb.AppendLine("auction_id " + auction_id); uint item_entry = gr2.ReadUInt32(); sb.AppendLine("item_entry " + item_entry); uint ench1_1 = gr2.ReadUInt32(); uint ench1_2 = gr2.ReadUInt32(); uint ench1_3 = gr2.ReadUInt32(); sb.AppendLine("enchant1 " + ench1_1 + " " + ench1_2 + " " + ench1_3); uint ench2_1 = gr2.ReadUInt32(); uint ench2_2 = gr2.ReadUInt32(); uint ench2_3 = gr2.ReadUInt32(); sb.AppendLine("enchant2 " + ench2_1 + " " + ench2_2 + " " + ench2_3); uint socket1_1 = gr2.ReadUInt32(); uint socket1_2 = gr2.ReadUInt32(); uint socket1_3 = gr2.ReadUInt32(); sb.AppendLine("socket1 " + socket1_1 + " " + socket1_2 + " " + socket1_3); uint socket2_1 = gr2.ReadUInt32(); uint socket2_2 = gr2.ReadUInt32(); uint socket2_3 = gr2.ReadUInt32(); sb.AppendLine("socket2 " + socket2_1 + " " + socket2_2 + " " + socket2_3); uint socket3_1 = gr2.ReadUInt32(); uint socket3_2 = gr2.ReadUInt32(); uint socket3_3 = gr2.ReadUInt32(); sb.AppendLine("socket3 " + socket3_1 + " " + socket3_2 + " " + socket3_3); uint bonus_1 = gr2.ReadUInt32(); uint bonus_2 = gr2.ReadUInt32(); uint bonus_3 = gr2.ReadUInt32(); sb.AppendLine("bonus " + bonus_1 + " " + bonus_2 + " " + bonus_3); uint rand = gr2.ReadUInt32(); sb.AppendLine("random property " + rand); uint unk1 = gr2.ReadUInt32(); sb.AppendLine("unk1 " + unk1); uint itemcount = gr2.ReadUInt32(); sb.AppendLine("item count " + itemcount); uint charges = gr2.ReadUInt32(); sb.AppendLine("charges " + charges); uint unk2 = gr2.ReadUInt32(); sb.AppendLine("unk2 " + unk2); if (unk2 != 0) { swe.WriteLine("unk2 " + unk2); } ulong owner = gr2.ReadUInt64(); uint startbid = gr2.ReadUInt32(); uint outbid = gr2.ReadUInt32(); uint buyout = gr2.ReadUInt32(); uint time = gr2.ReadUInt32(); sb.AppendLine("owner: " + owner + " " + startbid + " " + outbid + " " + buyout + " " + time); ulong bidder = gr2.ReadUInt64(); uint bid = gr2.ReadUInt32(); sb.AppendLine("bidder " + bidder + " " + bid); sb.AppendLine(); } uint totalcount = gr2.ReadUInt32(); return(true); }
public static bool ParseSpellNonMeleeDamageLogOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { StreamWriter sw = new StreamWriter("SpellNonMeleeDamageLog.log", true, Encoding.ASCII); sw.WriteLine("Packet offset {0}", gr.BaseStream.Position.ToString("X2")); sw.WriteLine("Opcode SpellNonMeleeDamageLog (0x0250)"); ulong target = gr2.ReadPackedGuid(); ulong caster = gr2.ReadPackedGuid(); sw.WriteLine("target {0}, caster {1}", target, caster); uint spellid = gr2.ReadUInt32(); sw.WriteLine("spell {0}", spellid); uint damage = gr2.ReadUInt32(); sw.WriteLine("damage {0}", damage); byte unk1 = gr2.ReadByte(); sw.WriteLine("unk1 {0}", unk1); uint adsorb = gr2.ReadUInt32(); sw.WriteLine("adsorb {0}", adsorb); uint resist = gr2.ReadUInt32(); sw.WriteLine("resist {0}", resist); byte unk2 = gr2.ReadByte(); sw.WriteLine("unk2 {0}", unk2); byte unk3 = gr2.ReadByte(); sw.WriteLine("unk3 {0}", unk3); uint blocked = gr2.ReadUInt32(); sw.WriteLine("blocked {0}", blocked); uint flags = gr2.ReadUInt32(); sw.WriteLine("flags {0}", flags.ToString("X8")); byte unk4 = gr2.ReadByte(); sw.WriteLine("unk4 {0}", unk4); if ((flags & 0x1) != 0) { float a = gr2.ReadSingle(); float b = gr2.ReadSingle(); sw.WriteLine("0x1: a {0}, b {1}", a, b); } if ((flags & 0x4) != 0) { float a = gr2.ReadSingle(); float b = gr2.ReadSingle(); sw.WriteLine("0x4: a {0}, b {1}", a, b); } if ((flags & 0x20) != 0) { float a = gr2.ReadSingle(); float b = gr2.ReadSingle(); float c = gr2.ReadSingle(); float d = gr2.ReadSingle(); float e = gr2.ReadSingle(); float f = gr2.ReadSingle(); sw.WriteLine("0x20: a {0}, b {1}, c {2}, d {3}, e {4}, f {5}", a, b, c, d, e, f); } if (gr2.BaseStream.Position != gr2.BaseStream.Length) { sw.WriteLine("F**K!: " + flags.ToString("X8")); } sw.WriteLine(); sw.Flush(); sw.Close(); return(true); }
/// <summary> /// /// </summary> /// <param name="gr"></param> /// <param name="gr2"></param> /// <param name="sb"></param> /// <param name="swe"></param> /// <returns></returns> public static bool ParsePartyMemberStatsOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset " + gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_PARTY_MEMBER_STATS (0x007E)"); byte MAX_AURAS = 56; ulong guid = gr2.ReadPackedGuid(); sb.AppendLine("GUID " + guid.ToString("X16")); GroupUpdateFlags flags = (GroupUpdateFlags)gr2.ReadUInt32(); sb.AppendLine("Flags " + flags); if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_ONLINE) != 0) { GroupMemberOnlineStatus online = (GroupMemberOnlineStatus)gr2.ReadUInt16(); // flag sb.AppendLine("Online state " + online); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_CUR_HP) != 0) { ushort hp = gr2.ReadUInt16(); sb.AppendLine("Cur. health " + hp); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_MAX_HP) != 0) { ushort maxhp = gr2.ReadUInt16(); sb.AppendLine("Max health " + maxhp); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_POWER_TYPE) != 0) { Powers power = (Powers)gr2.ReadByte(); sb.AppendLine("Power type " + power); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_CUR_POWER) != 0) { ushort curpower = gr2.ReadUInt16(); sb.AppendLine("Cur. power " + curpower); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_MAX_POWER) != 0) { ushort maxpower = gr2.ReadUInt16(); sb.AppendLine("Max power " + maxpower); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_LEVEL) != 0) { ushort level = gr2.ReadUInt16(); sb.AppendLine("Level " + level); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_ZONE) != 0) { ushort zone = gr2.ReadUInt16(); sb.AppendLine("Zone " + zone); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_POSITION) != 0) { short x = gr2.ReadInt16(); short y = gr2.ReadInt16(); sb.AppendLine("Position: " + x + ", " + y); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_AURAS) != 0) { ulong mask = gr2.ReadUInt64(); sb.AppendLine("Auras mask " + mask.ToString("X16")); BitArray bitArr = new BitArray(BitConverter.GetBytes(mask)); for (int i = 0; i < bitArr.Length; i++) { if (i >= MAX_AURAS) // we can have only 56 auras { break; } if (bitArr[i]) { ushort spellid = gr2.ReadUInt16(); sb.AppendLine("Aura " + i.ToString() + ": " + spellid.ToString()); byte unk = gr2.ReadByte(); sb.AppendLine("Aura unk " + i.ToString() + ": " + unk.ToString()); } } } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_GUID) != 0) { ulong petguid = gr2.ReadUInt64(); sb.AppendLine("Pet guid " + petguid.ToString("X16")); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_NAME) != 0) { string name = gr2.ReadStringNull(); sb.AppendLine("Pet name " + name); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_MODEL_ID) != 0) { ushort modelid = gr2.ReadUInt16(); sb.AppendLine("Pet model id " + modelid); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_CUR_HP) != 0) { ushort pethp = gr2.ReadUInt16(); sb.AppendLine("Pet cur. HP " + pethp); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_MAX_HP) != 0) { ushort petmaxhp = gr2.ReadUInt16(); sb.AppendLine("Pet max HP " + petmaxhp); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_POWER_TYPE) != 0) { Powers power = (Powers)gr2.ReadByte(); sb.AppendLine("Pet power type " + power); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_CUR_POWER) != 0) { ushort petpower = gr2.ReadUInt16(); sb.AppendLine("Pet cur. power " + petpower); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_MAX_POWER) != 0) { ushort petmaxpower = gr2.ReadUInt16(); sb.AppendLine("Pet max power " + petmaxpower); } if ((flags & GroupUpdateFlags.GROUP_UPDATE_FLAG_PET_AURAS) != 0) { ulong mask = gr2.ReadUInt64(); sb.AppendLine("Pet auras mask " + mask.ToString("X16")); BitArray bitArr = new BitArray(BitConverter.GetBytes(mask)); for (int i = 0; i < bitArr.Length; i++) { if (i >= MAX_AURAS) // we can have only 56 auras { break; } if (bitArr[i]) { ushort spellid = gr2.ReadUInt16(); sb.AppendLine("Pet aura " + i.ToString() + ": " + spellid.ToString()); byte unk = gr2.ReadByte(); sb.AppendLine("Pet aura unk " + i.ToString() + ": " + unk.ToString()); } i++; } } if (gr2.BaseStream.Position == gr2.BaseStream.Length) { sb.AppendLine("parsed: ok..."); } else { sb.AppendLine("parsed: error..."); } return(true); }
private bool ParseValuesUpdateBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data, ObjectTypes objectTypeId, UpdateTypes updatetype) { // may be we can reduce size of code there... sb.AppendLine("=== values_update_block_start ==="); byte blocks_count = gr.ReadByte(); // count of update blocks (4 bytes for each update block) sb.AppendLine("Bit mask blocks count: " + blocks_count); uint[] updatemask = new uint[blocks_count]; // create array of update blocks for (int j = 0; j < blocks_count; j++) updatemask[j] = gr.ReadUInt32(); // populate array of update blocks with data Mask = (BitArr)updatemask; // convert array of update blocks to bitmask array int reallength = Mask.RealLength; // bitmask size (bits) // item/container values update block if (objectTypeId == ObjectTypes.TYPEID_ITEM || objectTypeId == ObjectTypes.TYPEID_CONTAINER) { if (reallength > 160) // 5*32, ?? { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing ITEM values update block, count " + reallength); return false; } for (uint index = 0; index < reallength; index++) { if (index > UpdateFields.ITEM_END) break; if (Mask[index]) { switch (UpdateFields.item_updatefields[index].type) { case 1: sb.AppendLine(UpdateFields.item_updatefields[index].name + " (" + index + "): " + gr.ReadSingle().ToString().Replace(",", ".")); break; default: sb.AppendLine(UpdateFields.item_updatefields[index].name + " (" + index + "): " + gr.ReadUInt32()); break; } } } } // unit values update block if (objectTypeId == ObjectTypes.TYPEID_UNIT) { if (reallength > 256) // 32*8 (for units bitmask = 8) { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing UNIT values update block, count " + reallength); return false; } for (uint index = 0; index < reallength; index++) { if (index > UpdateFields.UNIT_END) break; if (Mask[index]) { switch (UpdateFields.unit_updatefields[index].type) { case 1: string val1 = gr.ReadSingle().ToString().Replace(",", "."); if(updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) data.WriteLine(UpdateFields.unit_updatefields[index].name + " (" + index + "): " + val1); sb.AppendLine(UpdateFields.unit_updatefields[index].name + " (" + index + "): " + val1); break; default: uint val2 = gr.ReadUInt32(); if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) data.WriteLine(UpdateFields.unit_updatefields[index].name + " (" + index + "): " + val2); sb.AppendLine(UpdateFields.unit_updatefields[index].name + " (" + index + "): " + val2); break; } } } } // player values update block if (objectTypeId == ObjectTypes.TYPEID_PLAYER) { if (reallength > 1440) // 32*45 (for player bitmask = 45) { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing PLAYER values update block, count " + reallength); return false; } for (uint index = 0; index < reallength; index++) { if (index > UpdateFields.PLAYER_END) break; if (Mask[index]) { switch (UpdateFields.unit_updatefields[index].type) { case 1: string val1 = gr.ReadSingle().ToString().Replace(",", "."); sb.AppendLine(UpdateFields.unit_updatefields[index].name + " (" + index + "): " + val1); break; default: uint val2 = gr.ReadUInt32(); sb.AppendLine(UpdateFields.unit_updatefields[index].name + " (" + index + "): " + val2); break; } } } } // gameobject values update block if (objectTypeId == ObjectTypes.TYPEID_GAMEOBJECT) { if (reallength > 32) // 1*32 { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing GO values update block, count " + reallength); return false; } for (uint index = 0; index < reallength; index++) { if (index > UpdateFields.GO_END) break; if (Mask[index]) { switch (UpdateFields.go_updatefields[index].type) { case 1: string val1 = gr.ReadSingle().ToString().Replace(",", "."); if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) data.WriteLine(UpdateFields.go_updatefields[index].name + " (" + index + "): " + val1); sb.AppendLine(UpdateFields.go_updatefields[index].name + " (" + index + "): " + val1); break; default: uint val2 = gr.ReadUInt32(); if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) data.WriteLine(UpdateFields.go_updatefields[index].name + " (" + index + "): " + val2); sb.AppendLine(UpdateFields.go_updatefields[index].name + " (" + index + "): " + val2); break; } } } } // dynamicobject values update block if (objectTypeId == ObjectTypes.TYPEID_DYNAMICOBJECT) { if (reallength > 32) // 1*32 { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing DO values update block, count " + reallength); return false; } for (uint index = 0; index < reallength; index++) { if (index > UpdateFields.DO_END) break; if (Mask[index]) { switch (UpdateFields.do_updatefields[index].type) { case 1: sb.AppendLine(UpdateFields.do_updatefields[index].name + " (" + index + "): " + gr.ReadSingle().ToString().Replace(",", ".")); break; default: sb.AppendLine(UpdateFields.do_updatefields[index].name + " (" + index + "): " + gr.ReadUInt32()); break; } } } } // corpse values update block if (objectTypeId == ObjectTypes.TYPEID_CORPSE) { if (reallength > 64) // 2*32 { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("error while parsing CORPSE values update block, count " + reallength); return false; } for (uint index = 0; index < reallength; index++) { if (index > UpdateFields.CORPSE_END) break; if (Mask[index]) { switch (UpdateFields.corpse_updatefields[index].type) { case 1: sb.AppendLine(UpdateFields.corpse_updatefields[index].name + " (" + index + "): " + gr.ReadSingle().ToString().Replace(",", ".")); break; default: sb.AppendLine(UpdateFields.corpse_updatefields[index].name + " (" + index + "): " + gr.ReadUInt32()); break; } } } } //swe.WriteLine("ok..."); sb.AppendLine("=== values_update_block_end ==="); return true; }
public void Read(GenericReader r) { var size = r.ReadUInt32(); if (size != 124) { throw new FileFormatException($"Invalid DDS file header size: {size}."); } dwFlags = (DDSFlags)r.ReadUInt32(); if (!Utils.ContainsBitFlags((int)dwFlags, (int)DDSFlags.Height, (int)DDSFlags.Width)) { throw new FileFormatException($"Invalid DDS file flags: {dwFlags}."); } dwHeight = r.ReadUInt32(); dwWidth = r.ReadUInt32(); dwPitchOrLinearSize = r.ReadUInt32(); dwDepth = r.ReadUInt32(); dwMipMapCount = r.ReadUInt32(); dwReserved1 = new uint[11]; for (var i = 0; i < 11; i++) { dwReserved1[i] = r.ReadUInt32(); } ddspf = new DDSPixelFormat(r); dwCaps = (DDSCaps)r.ReadUInt32(); if (!Utils.ContainsBitFlags((int)dwCaps, (int)DDSCaps.Texture)) { throw new FileFormatException($"Invalid DDS file caps: {dwCaps}."); } dwCaps2 = (DDSCaps2)r.ReadUInt32(); dwCaps3 = r.ReadUInt32(); dwCaps4 = r.ReadUInt32(); dwReserved2 = r.ReadUInt32(); }
private static bool ParseBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data) { ulong guid = 0; UpdateTypes updatetype = (UpdateTypes)gr.ReadByte(); sb.AppendLine("Updatetype: " + updatetype); // check if updatetype is valid if (updatetype < UpdateTypes.UPDATETYPE_VALUES || updatetype > UpdateTypes.UPDATETYPE_NEAR_OBJECTS) { long pos = gr.BaseStream.Position; swe.WriteLine("wrong updatetype at position {0}", pos.ToString("X16")); // we there only if we read packet wrong way swe.WriteLine("Updatetype {0} is not supported", updatetype); return(false); } switch (updatetype) { case UpdateTypes.UPDATETYPE_VALUES: guid = gr.ReadPackedGuid(); sb.AppendLine("Object guid: " + guid.ToString("X16")); if (guid == 0) { long pos = gr.BaseStream.Position; swe.WriteLine("wrong guid at position {0}", pos.ToString("X2")); // we there only if we read packet wrong way swe.WriteLine("Updatetype {0} can't be with NULL guid", updatetype); return(false); } ObjectTypes objecttype = ObjectTypes.TYPEID_OBJECT; // 0 if (Binparser.m_objects.ContainsKey(guid)) { objecttype = Binparser.m_objects[guid]; } else // try old method... { // object type auto detection: // F00C0000, F02B0000 - gameobjects // F00CXXXX, F02BXXXX - units (XXXX == 0000 for pets etc...) // F02B00000000XXXX - corpses // F02B00000000XXXX - dynamicobjects if (guid.ToString("X16").Substring(0, 8).Equals("40000000")) { objecttype = ObjectTypes.TYPEID_ITEM; } else if (guid.ToString("X16").Substring(0, 8).Equals("00000000")) { objecttype = ObjectTypes.TYPEID_PLAYER; } else { objecttype = ObjectTypes.TYPEID_UNIT; // also can be go, do, corpse } swe.WriteLine("problem with objecttypeid detection for UPDATETYPE_VALUES"); } sb.AppendLine("objectTypeId " + objecttype); if (!ParseValuesUpdateBlock(gr, sb, swe, data, objecttype, updatetype, null)) { return(false); } return(true); case UpdateTypes.UPDATETYPE_MOVEMENT: guid = gr.ReadPackedGuid(); sb.AppendLine("Object guid: " + guid.ToString("X16")); if (!ParseMovementUpdateBlock(gr, sb, swe, data, ObjectTypes.TYPEID_UNIT, null)) { return(false); } return(true); case UpdateTypes.UPDATETYPE_CREATE_OBJECT: case UpdateTypes.UPDATETYPE_CREATE_OBJECT2: guid = gr.ReadPackedGuid(); sb.AppendLine("Object guid: " + guid.ToString("X16")); ObjectTypes objectTypeId = (ObjectTypes)gr.ReadByte(); sb.AppendLine("objectTypeId " + objectTypeId); // check object existance and remove it if needed... //if (Binparser.m_objects.ContainsKey(guid)) // Binparser.m_objects.Remove(guid); // now we can add this object to Dictionary to get correct object type later... //Binparser.m_objects.Add(guid, objectTypeId); WoWObject obj = new WoWObject(0, objectTypeId); // add new object only if we not have it already if (!Binparser.m_objects.ContainsKey(guid)) { obj.IsNew = true; Binparser.m_objects.Add(guid, objectTypeId); } switch (objectTypeId) { case ObjectTypes.TYPEID_OBJECT: case ObjectTypes.TYPEID_AIGROUP: case ObjectTypes.TYPEID_AREATRIGGER: swe.WriteLine("Unhandled object type {0}", objectTypeId); return(false); case ObjectTypes.TYPEID_ITEM: case ObjectTypes.TYPEID_CONTAINER: case ObjectTypes.TYPEID_UNIT: case ObjectTypes.TYPEID_PLAYER: case ObjectTypes.TYPEID_GAMEOBJECT: case ObjectTypes.TYPEID_DYNAMICOBJECT: case ObjectTypes.TYPEID_CORPSE: if (!ParseMovementUpdateBlock(gr, sb, swe, data, objectTypeId, obj)) { return(false); } if (!ParseValuesUpdateBlock(gr, sb, swe, data, objectTypeId, updatetype, obj)) { return(false); } return(true); default: swe.WriteLine("Unknown object type {0}", objectTypeId); return(false); } case UpdateTypes.UPDATETYPE_OUT_OF_RANGE_OBJECTS: case UpdateTypes.UPDATETYPE_NEAR_OBJECTS: uint objects_count = gr.ReadUInt32(); if (objects_count > 1000) // we read packet wrong way { long pos = gr.BaseStream.Position; swe.WriteLine("error position {0}", pos.ToString("X2")); swe.WriteLine("Too many {0} objects", updatetype); return(false); } sb.AppendLine("guids_count " + objects_count); for (uint i = 0; i < objects_count; i++) { sb.AppendLine("Guid" + i + ": " + gr.ReadPackedGuid().ToString("X16")); } return(true); default: swe.WriteLine("Unknown updatetype {0}", updatetype); return(false); } }
public SiMeshLod(GenericReader r) { var bsp = r.Position; MeshSize = r.ReadUInt32(); Flags = r.ReadUInt32(); Unused1 = r.ReadUInt32(); SphereCenter = r.ReadVector3(); SphereRadius = r.ReadSingle(); MinBounds = r.ReadVector3(); MaxBounds = r.ReadVector3(); Ignorable1 = r.ReadUInt32(); Ignorable2 = r.ReadUInt32(); FaceCount = r.ReadUInt32(); MountFaceCount = r.ReadUInt32(); VertexCount = r.ReadUInt32(); MountVertexCount = r.ReadUInt32(); MaxFaceCount = r.ReadUInt32(); MaterialCount = r.ReadUInt32(); FaceOffset = r.ReadUInt32(); MountFaceOffset = r.ReadUInt32(); VertexOffset = r.ReadUInt32(); MountVertexCount2 = r.ReadUInt32(); MaterialOffset = r.ReadUInt32(); SortedFacesOffset[0] = r.ReadUInt32(); SortedFacesOffset[1] = r.ReadUInt32(); SortedFacesOffset[2] = r.ReadUInt32(); SortedFacesOffset[3] = r.ReadUInt32(); ProbablyUnused1 = r.ReadUInt32(); ProbablyUnused2 = r.ReadUInt32(); // r.Position = bsp + FaceOffset + 4; Faces = new SiFace[FaceCount]; for (var i = 0; i < Faces.Length; i++) { Faces[i] = new SiFace(r); } r.Position = bsp + VertexOffset + 4; Vertices = new Vector3[VertexCount]; for (var i = 0; i < Vertices.Length; i++) { Vertices[i] = r.ReadVector3(); } r.Position = bsp + MaterialOffset + 4; Materials = new SiMaterial[MaterialCount]; for (var i = 0; i < Materials.Length; i++) { Materials[i] = new SiMaterial(r); } }
private uint ParsePacket(GenericReader gr, StreamWriter sw, StreamWriter swe, StreamWriter data) { StringBuilder sb = new StringBuilder(); //MessageBox.Show(br.BaseStream.Position.ToString() + " " + br.BaseStream.Length.ToString()); uint opcode = gr.ReadUInt16(); if (opcode != 0x00A9) { return 2; } sb.AppendLine("Packet offset " + (gr.BaseStream.Position - 2).ToString("X2")); sb.AppendLine("Packet number: " + packet); sb.AppendLine("Opcode: " + opcode.ToString("X4")); uint count = gr.ReadUInt32(); sb.AppendLine("Object count: " + count); uint unk = gr.ReadByte(); sb.AppendLine("Unk: " + unk); for (uint i = 1; i < count+1; i++) { sb.AppendLine("Update block for object " + i + ":"); sb.AppendLine("Block offset " + gr.BaseStream.Position.ToString("X2")); if (!ParseBlock(gr, sb, swe, data)) { sw.WriteLine(sb.ToString()); return 1; } } sw.WriteLine(sb.ToString()); return 0; }
void ReadMetadata() { // Open Magic = _r.ReadUInt32(); if (Magic == F4_BSAHEADER_FILEID) { Version = _r.ReadUInt32(); if (Version != F4_BSAHEADER_VERSION) { throw new InvalidOperationException("BAD MAGIC"); } // Read the header var header_Type = _r.ReadASCIIString(4); // 08 GNRL=General, DX10=Textures var header_NumFiles = _r.ReadUInt32(); // 0C var header_NameTableOffset = _r.ReadUInt64(); // 10 - relative to start of file // Create file metadatas _r.Position = (long)header_NameTableOffset; _files = new FileMetadata[header_NumFiles]; for (var i = 0; i < header_NumFiles; i++) { var length = _r.ReadUInt16(); var path = _r.ReadASCIIString(length).Replace('\\', '/'); _files[i] = new FileMetadata { Path = path, PathHash = Tes4HashFilePath(path), }; } if (header_Type == "GNRL") // General BA2 Format { _r.Position = 16 + 8; // sizeof(header) + 8 for (var i = 0; i < header_NumFiles; i++) { var info_NameHash = _r.ReadUInt32(); // 00 var info_Ext = _r.ReadASCIIString(4); // 04 - extension var info_DirHash = _r.ReadUInt32(); // 08 var info_Unk0C = _r.ReadUInt32(); // 0C - flags? 00100100 var info_Offset = _r.ReadUInt64(); // 10 - relative to start of file var info_PackedSize = _r.ReadUInt32(); // 18 - packed length (zlib) var info_UnpackedSize = _r.ReadUInt32(); // 1C - unpacked length var info_Unk20 = _r.ReadUInt32(); // 20 - BAADF00D _files[i].PackedSize = info_PackedSize; _files[i].UnpackedSize = info_UnpackedSize; _files[i].Offset = (long)info_Offset; } } else if (header_Type == "DX10") // Texture BA2 Format { _r.Position = 16 + 8; // sizeof(header) + 8 for (var i = 0; i < header_NumFiles; i++) { var fileMetadata = _files[i]; var info_NameHash = _r.ReadUInt32(); // 00 var info_Ext = _r.ReadASCIIString(4); // 04 var info_DirHash = _r.ReadUInt32(); // 08 var info_Unk0C = _r.ReadByte(); // 0C var info_NumChunks = _r.ReadByte(); // 0D var info_ChunkHeaderSize = _r.ReadUInt16(); // 0E - size of one chunk header var info_Height = _r.ReadUInt16(); // 10 var info_Width = _r.ReadUInt16(); // 12 var info_NumMips = _r.ReadByte(); // 14 var info_Format = _r.ReadByte(); // 15 - DXGI_FORMAT var info_Unk16 = _r.ReadUInt16(); // 16 - 0800 // read tex-chunks var texChunks = new F4TexChunk[info_NumChunks]; for (var j = 0; j < info_NumChunks; j++) { texChunks[j] = new F4TexChunk { Offset = _r.ReadUInt64(), // 00 PackedSize = _r.ReadUInt32(), // 08 UnpackedSize = _r.ReadUInt32(), // 0C StartMip = _r.ReadUInt16(), // 10 EndMip = _r.ReadUInt16(), // 12 Unk14 = _r.ReadUInt32(), // 14 - BAADFOOD } } ; var firstChunk = texChunks[0]; _files[i].PackedSize = firstChunk.PackedSize; _files[i].UnpackedSize = firstChunk.UnpackedSize; _files[i].Offset = (long)firstChunk.Offset; fileMetadata.Tex = new F4Tex { Height = info_Height, Width = info_Width, NumMips = info_NumMips, Format = (DXGIFormat)info_Format, Unk16 = info_Unk16, Chunks = texChunks, }; } } } else if (Magic == OB_BSAHEADER_FILEID) { Version = _r.ReadUInt32(); if (Version != OB_BSAHEADER_VERSION && Version != F3_BSAHEADER_VERSION && Version != SSE_BSAHEADER_VERSION) { throw new InvalidOperationException("BAD MAGIC"); } // Read the header var header_FolderRecordOffset = _r.ReadUInt32(); // Offset of beginning of folder records var header_ArchiveFlags = _r.ReadUInt32(); // Archive flags var header_FolderCount = _r.ReadUInt32(); // Total number of folder records (OBBSAFolderInfo) var header_FileCount = _r.ReadUInt32(); // Total number of file records (OBBSAFileInfo) var header_FolderNameLength = _r.ReadUInt32(); // Total length of folder names var header_FileNameLength = _r.ReadUInt32(); // Total length of file names var header_FileFlags = _r.ReadUInt32(); // File flags // Calculate some useful values if ((header_ArchiveFlags & OB_BSAARCHIVE_PATHNAMES) == 0 || (header_ArchiveFlags & OB_BSAARCHIVE_FILENAMES) == 0) { throw new InvalidOperationException("HEADER FLAGS"); } _compressToggle = (header_ArchiveFlags & OB_BSAARCHIVE_COMPRESSFILES) != 0; if (Version == F3_BSAHEADER_VERSION || Version == SSE_BSAHEADER_VERSION) { _hasNamePrefix = (header_ArchiveFlags & F3_BSAARCHIVE_PREFIXFULLFILENAMES) != 0; } var folderSize = Version != SSE_BSAHEADER_VERSION ? 16 : 24; // Create file metadatas _files = new FileMetadata[header_FileCount]; var filenamesSectionStartPos = _r.Position = header_FolderRecordOffset + header_FolderNameLength + header_FolderCount * (folderSize + 1) + header_FileCount * 16; var buf = new List <byte>(64); for (var i = 0; i < header_FileCount; i++) { buf.Clear(); byte curCharAsByte; while ((curCharAsByte = _r.ReadByte()) != 0) { buf.Add(curCharAsByte); } var path = Encoding.ASCII.GetString(buf.ToArray()).Replace('\\', '/'); _files[i] = new FileMetadata { Path = path, }; } if (_r.Position != filenamesSectionStartPos + header_FileNameLength) { throw new InvalidOperationException("HEADER FILENAMES"); } // read-all folders _r.Position = header_FolderRecordOffset; var foldersFiles = new uint[header_FolderCount]; for (var i = 0; i < header_FolderCount; i++) { var folder_Hash = _r.ReadUInt64(); // Hash of the folder name var folder_FileCount = _r.ReadUInt32(); // Number of files in folder var folder_Unk = 0U; var folder_Offset = 0UL; if (Version == SSE_BSAHEADER_VERSION) { folder_Unk = _r.ReadUInt32(); folder_Offset = _r.ReadUInt64(); } else { folder_Offset = _r.ReadUInt32(); } foldersFiles[i] = folder_FileCount; } // add file var fileNameIndex = 0U; for (var i = 0; i < header_FolderCount; i++) { var folder_name = _r.ReadASCIIString(_r.ReadByte(), ASCIIFormat.PossiblyNullTerminated).Replace('\\', '/'); // BSAReadSizedString var folderFiles = foldersFiles[i]; for (var j = 0; j < folderFiles; j++) { var file_Hash = _r.ReadUInt64(); // Hash of the filename var file_SizeFlags = _r.ReadUInt32(); // Size of the data, possibly with OB_BSAFILE_FLAG_COMPRESS set var file_Offset = _r.ReadUInt32(); // Offset to raw file data var fileMetadata = _files[fileNameIndex++]; fileMetadata.SizeFlags = file_SizeFlags; fileMetadata.Offset = file_Offset; fileMetadata.Path = folder_name + "/" + fileMetadata.Path; fileMetadata.PathHash = Tes4HashFilePath(fileMetadata.Path); } } } else if (Magic == MW_BSAHEADER_FILEID) { // Read the header var header_HashOffset = _r.ReadUInt32(); // Offset of hash table minus header size (12) var header_FileCount = _r.ReadUInt32(); // Number of files in the archive // Calculate some useful values var headerSize = _r.Position; var hashTablePosition = headerSize + header_HashOffset; var fileDataSectionPostion = hashTablePosition + (8 * header_FileCount); // Create file metadatas _files = new FileMetadata[header_FileCount]; for (var i = 0; i < header_FileCount; i++) { _files[i] = new FileMetadata { // Read file sizes/offsets SizeFlags = _r.ReadUInt32(), Offset = fileDataSectionPostion + _r.ReadUInt32(), } } ; // Read filename offsets var filenameOffsets = new uint[header_FileCount]; // relative offset in filenames section for (var i = 0; i < header_FileCount; i++) { filenameOffsets[i] = _r.ReadUInt32(); } // Read filenames var filenamesSectionStartPos = _r.Position; var buf = new List <byte>(64); for (var i = 0; i < header_FileCount; i++) { _r.Position = filenamesSectionStartPos + filenameOffsets[i]; buf.Clear(); byte curCharAsByte; while ((curCharAsByte = _r.ReadByte()) != 0) { buf.Add(curCharAsByte); } _files[i].Path = Encoding.ASCII.GetString(buf.ToArray()).Replace('\\', '/'); } // Read filename hashes _r.Position = hashTablePosition; for (var i = 0; i < header_FileCount; i++) { //_files[i].PathHash = _r.ReadUInt64(); _files[i].PathHash = Tes3HashFilePath(_files[i].Path); } } else { throw new InvalidOperationException("BAD MAGIC"); } // Create the file metadata hash table _filesByHash = _files.ToLookup(x => x.PathHash); } ulong HashFilePath(string filePath) { if (Magic == MW_BSAHEADER_FILEID) { return(Tes3HashFilePath(filePath)); } else { return(Tes4HashFilePath(filePath)); } }
public static bool ParseAttackerStateUpdateOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset " + gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_ATTACKERSTATEUPDATE (0x01B1)"); StreamWriter sw = new StreamWriter("attacker_state.log", true, Encoding.ASCII); HitInfo hi = (HitInfo)gr2.ReadUInt32(); ulong attacker = gr2.ReadPackedGuid(); ulong target = gr2.ReadPackedGuid(); uint damage = gr2.ReadUInt32(); sw.WriteLine("HitInfo {0}", hi); sw.WriteLine("attacker {0}", attacker.ToString("X16")); sw.WriteLine("target {0}", target.ToString("X16")); sw.WriteLine("damage {0}", damage); byte count = gr2.ReadByte(); sw.WriteLine("count {0}", count); for (byte i = 0; i < count; i++) { ITEM_DAMAGE_TYPE damagetype = (ITEM_DAMAGE_TYPE)gr2.ReadUInt32(); float damage2 = gr2.ReadSingle(); uint damage3 = gr2.ReadUInt32(); uint adsorb = gr2.ReadUInt32(); uint resist = gr2.ReadUInt32(); sw.WriteLine("damagetype {0}", damagetype); sw.WriteLine("damage2 {0}", damage2); sw.WriteLine("damage3 {0}", damage3); sw.WriteLine("adsorb {0}", adsorb); sw.WriteLine("resist {0}", resist); } VictimState targetstate = (VictimState)gr2.ReadUInt32(); uint unk1 = gr2.ReadUInt32(); uint unk2 = gr2.ReadUInt32(); uint blocked = gr2.ReadUInt32(); sw.WriteLine("targetstate {0}", targetstate); sw.WriteLine("unk1 {0}", unk1); sw.WriteLine("unk2 {0}", unk2); sw.WriteLine("blocked {0}", blocked); sw.WriteLine(); sw.Flush(); sw.Close(); if (gr2.BaseStream.Position == gr2.BaseStream.Length) { sb.AppendLine("parsed: ok..."); } else { sb.AppendLine("parsed: error..."); } return(true); }
/// <summary> /// Monster move opcode parser method. /// </summary> /// <param name="gr">Main stream reader.</param> /// <param name="gr2">Packet stream reader.</param> /// <param name="sb">Logger string builder.</param> /// <param name="swe">Error logger writer.</param> /// <returns>Successful</returns> public static bool ParseMonsterMoveOpcode(GenericReader gr, GenericReader gr2, StringBuilder sb, StreamWriter swe, byte direction) { sb.AppendLine("Packet offset " + gr.BaseStream.Position.ToString("X2")); sb.AppendLine("Opcode SMSG_MONSTER_MOVE (0x00DD)"); ulong guid = gr2.ReadPackedGuid(); sb.AppendLine("GUID " + guid.ToString("X16")); Coords3 coords = gr2.ReadCoords3(); sb.AppendLine("Start point " + coords.GetCoords()); uint time = gr2.ReadUInt32(); sb.AppendLine("Time " + time); byte unk = gr2.ReadByte(); sb.AppendLine("unk_byte " + unk); switch (unk) { case 0: // обычный пакет break; case 1: // стоп, конец пакета... sb.AppendLine("stop"); return(true); case 2: Coords3 point = gr2.ReadCoords3(); sb.AppendLine("unk point " + point.GetCoords()); break; case 3: // чей-то гуид, скорее всего таргета... ulong target_guid = gr2.ReadUInt64(); sb.AppendLine("GUID unknown " + target_guid.ToString("X16")); break; case 4: // похоже на ориентацию... float orientation = gr2.ReadSingle(); sb.AppendLine("Orientation " + orientation.ToString().Replace(",", ".")); break; default: swe.WriteLine("Error in position " + gr.BaseStream.Position.ToString("X2")); swe.WriteLine("unknown unk " + unk); break; } Flags flags = (Flags)gr2.ReadUInt32(); sb.AppendLine("Flags " + flags); uint movetime = gr2.ReadUInt32(); sb.AppendLine("MoveTime " + movetime); uint points = gr2.ReadUInt32(); sb.AppendLine("Points " + points); List <Node> nodes = new List <Node>((int)points); if ((flags & Flags.flag10) != 0) // 0x200 { sb.AppendLine("Taxi"); for (uint i = 0; i < points; i++) { Node node = new Node(); node.x = gr2.ReadSingle(); node.y = gr2.ReadSingle(); node.z = gr2.ReadSingle(); nodes.Add(node); //Coords3 path = gr2.ReadCoords3(); //sb.AppendLine("Path point" + i + ": " + path.GetCoords()); } } else { if ((flags & Flags.flag09) == 0 && (flags & Flags.flag10) == 0 && flags != 0) { swe.WriteLine("Unknown flags " + flags); } if ((flags & Flags.flag09) != 0) { sb.AppendLine("Running"); } Coords3 end = gr2.ReadCoords3(); sb.AppendLine("End point " + end.GetCoords()); for (uint i = 0; i < (points - 1); i++) { int mask = gr2.ReadInt32(); sb.AppendLine("shift mask" + i + " " + mask.ToString("X8")); int temp1, temp2, temp3; temp1 = (mask & 0x07FF) << 0x15; temp2 = ((mask >> 0x0B) & 0x07FF) << 0x15; temp3 = (mask >> 0x16) << 0x16; temp1 >>= 0x15; temp2 >>= 0x15; temp3 >>= 0x16; float x = temp1 * 0.25f; float y = temp2 * 0.25f; float z = temp3 * 0.25f; sb.AppendLine("shift is " + x + " " + y + " " + z + "."); } } if ((flags & Flags.flag10) != 0) { StreamWriter sw = new StreamWriter("taxiinfo.txt", true); sw.WriteLine("GUID: 0x" + guid.ToString("X16")); sw.WriteLine(string.Format("Position: {0} {1} {2}", coords.X, coords.Y, coords.Z)); sw.WriteLine("Time: " + time); sw.WriteLine("Movetime: " + movetime); sw.WriteLine("Nodes: " + points); for (int i = 0; i < points; i++) { sw.WriteLine(string.Format("Node {0}: {1} {2} {3}", i, nodes[i].x, nodes[i].y, nodes[i].z)); } uint mangos_time = 0; float len = 0, xd, yd, zd; /*xd = nodes[0].x - coords.X; * yd = nodes[0].y - coords.Y; * zd = nodes[0].z - coords.Z; * len += (float)Math.Sqrt((xd * xd + yd * yd + zd * zd));*/ for (int i = 1; i < points; i++) { xd = nodes[i].x - nodes[i - 1].x; yd = nodes[i].y - nodes[i - 1].y; zd = nodes[i].z - nodes[i - 1].z; len += (float)Math.Sqrt((xd * xd + yd * yd + zd * zd)); } mangos_time = (uint)(len * 33.360f); // 33.373f / 33.336 sw.WriteLine("Mangostime 3D: " + mangos_time); mangos_time = 0; len = 0; for (int i = 1; i < points; i++) { xd = nodes[i].x - nodes[i - 1].x; yd = nodes[i].y - nodes[i - 1].y; len += (float)Math.Sqrt((xd * xd + yd * yd)); } mangos_time = (uint)(len * 33.360f); sw.WriteLine("Mangostime 2D: " + mangos_time); sw.WriteLine(); sw.Flush(); sw.Close(); } return(true); }
/// <summary> /// Packet header parser. /// </summary> /// <param name="gr">Main stream reader.</param> /// <param name="sw">Data stream writer.</param> /// <param name="swe">Error logger writer.</param> /// <param name="data">Data logger writer.</param> /// <param name="hex">HEX logger writer.</param> /// <returns>Successful</returns> private static bool ParseHeader(GenericReader gr, StreamWriter sw, StreamWriter swe, StreamWriter data, StreamWriter hex) { StringBuilder sb = new StringBuilder(); int datasize = gr.ReadInt32(); //sb.AppendLine("Packet offset " + (gr.BaseStream.Position - 4).ToString("X2")); //sb.AppendLine("Packet number: " + packet); //sb.AppendLine("Data size " + datasize); byte[] temp = gr.ReadBytes(datasize); MemoryStream ms = new MemoryStream(temp); GenericReader gr2 = new GenericReader(ms); uint id = 0; uint sess_id = 0; string time = ""; byte direction = 0; // 0-CMSG, 1-SMSG OpCodes opcode = OpCodes.MSG_NULL_ACTION; id = gr2.ReadUInt32(); sess_id = gr2.ReadUInt32(); time = gr2.ReadStringNull(); direction = gr2.ReadByte(); opcode = (OpCodes)gr2.ReadUInt16(); long cur_pos = gr2.BaseStream.Position; HexLike(gr2, hex, id, sess_id, time, direction, opcode); gr2.BaseStream.Position = cur_pos; switch (opcode) { /*case OpCodes.SMSG_MONSTER_MOVE: * OpcodeParser.ParseMonsterMoveOpcode(gr, gr2, sb, swe, direction); * break;*/ /*case OpCodes.SMSG_INITIAL_SPELLS: * OpcodeParser.ParseInitialSpellsOpcode(gr, gr2, sb, swe, direction); * break; * case OpCodes.SMSG_AUCTION_LIST_RESULT: * OpcodeParser.ParseAuctionListResultOpcode(gr, gr2, sb, swe, direction); * break;*/ /*case OpCodes.SMSG_PARTY_MEMBER_STATS: * case OpCodes.SMSG_PARTY_MEMBER_STATS_FULL: * OpcodeParser.ParsePartyMemberStatsOpcode(gr, gr2, sb, swe, direction); * break;*/ case OpCodes.SMSG_UPDATE_OBJECT: case OpCodes.SMSG_COMPRESSED_UPDATE_OBJECT: if (opcode == OpCodes.SMSG_COMPRESSED_UPDATE_OBJECT) { gr2 = A9.Decompress(gr2); gr2.BaseStream.Position = 0; hex.WriteLine("Decompressed SMSG_COMPRESSED_UPDATE_OBJECT:"); HexLike(gr2, hex, id, sess_id, time, direction, OpCodes.SMSG_UPDATE_OBJECT); gr2.BaseStream.Position = 0; } A9.ParseUpdatePacket(gr, gr2, sb, swe); break; /*case OpCodes.SMSG_SPELLNONMELEEDAMAGELOG: * OpcodeParser.ParseSpellNonMeleeDamageLogOpcode(gr, gr2, sb, swe, direction); * break; * case OpCodes.SMSG_SPELLLOGEXECUTE: * OpcodeParser.ParseSpellLogExecuteOpcode(gr, gr2, sb, swe, direction); * break;*/ /*case OpCodes.SMSG_LOGIN_SETTIMESPEED: * OpcodeParser.ParseLoginSetTimeSpeedOpcode(gr, gr2, sb, swe, direction); * break; * case OpCodes.SMSG_TRAINER_LIST: * OpcodeParser.ParseTrainerListOpcode(gr, gr2, sb, swe, direction); * break; * case OpCodes.SMSG_ATTACKERSTATEUPDATE: * OpcodeParser.ParseAttackerStateUpdateOpcode(gr, gr2, sb, swe, direction); * break; * case OpCodes.MSG_CORPSE_QUERY: * OpcodeParser.ParseCorpseQueryOpcode(gr, gr2, sb, swe, direction); * break; * case OpCodes.SMSG_LOGIN_VERIFY_WORLD: * OpcodeParser.ParseLoginVerifyWorldOpcode(gr, gr2, sb, swe, direction); * break; * default: // unhandled opcode * return false;*/ } if (sb.ToString().Length != 0) { sw.WriteLine(sb.ToString()); } ms.Close(); gr2.Close(); return(true); }
private bool ParseBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data) { UpdateTypes updatetype = (UpdateTypes)gr.ReadByte(); sb.AppendLine("Updatetype: " + updatetype); if (updatetype < UpdateTypes.UPDATETYPE_VALUES || updatetype > UpdateTypes.UPDATETYPE_NEAR_OBJECTS) { long pos = gr.BaseStream.Position; swe.WriteLine("wrong updatetype at position " + pos.ToString("X2")); // we there only if we read packet wrong way swe.WriteLine("Updatetype " + updatetype + " is not supported"); return false; } if (updatetype == UpdateTypes.UPDATETYPE_VALUES) { ulong guid = gr.ReadPackedGuid(); sb.AppendLine("Object guid: " + guid.ToString("X16")); if (guid == 0) { long pos = gr.BaseStream.Position; swe.WriteLine("wrong guid at position " + pos.ToString("X2")); // we there only if we read packet wrong way swe.WriteLine("Updatetype " + updatetype + " can't be with NULL guid"); return false; } // object type detection: ObjectTypes objecttype; if (guid.ToString("X16").Substring(0, 8) == "40000000") objecttype = ObjectTypes.TYPEID_ITEM; else if (guid.ToString("X16").Substring(0, 8) == "00000000") objecttype = ObjectTypes.TYPEID_PLAYER; else objecttype = ObjectTypes.TYPEID_UNIT; if (!ParseValuesUpdateBlock(gr, sb, swe, data, objecttype, updatetype)) return false; return true; } if (updatetype == UpdateTypes.UPDATETYPE_MOVEMENT) { ulong guid = gr.ReadPackedGuid(); sb.AppendLine("Object guid: " + guid.ToString("X2")); if (!ParseMovementUpdateBlock(gr, sb, swe, data, ObjectTypes.TYPEID_UNIT)) return false; return true; } if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) { ulong guid = gr.ReadPackedGuid(); sb.AppendLine("Object guid: " + guid.ToString("X2")); ObjectTypes objectTypeId = (ObjectTypes)gr.ReadByte(); sb.AppendLine("objectTypeId " + objectTypeId); switch (objectTypeId) { case ObjectTypes.TYPEID_OBJECT: swe.WriteLine("Unhandled object type " + objectTypeId); break; case ObjectTypes.TYPEID_ITEM: case ObjectTypes.TYPEID_CONTAINER: case ObjectTypes.TYPEID_UNIT: case ObjectTypes.TYPEID_PLAYER: case ObjectTypes.TYPEID_GAMEOBJECT: case ObjectTypes.TYPEID_DYNAMICOBJECT: case ObjectTypes.TYPEID_CORPSE: if (!ParseMovementUpdateBlock(gr, sb, swe, data, objectTypeId)) return false; if (!ParseValuesUpdateBlock(gr, sb, swe, data, objectTypeId, updatetype)) return false; break; case ObjectTypes.TYPEID_AIGROUP: swe.WriteLine("Unhandled object type " + objectTypeId); break; case ObjectTypes.TYPEID_AREATRIGGER: swe.WriteLine("Unhandled object type " + objectTypeId); break; default: swe.WriteLine("Unknown object type " + objectTypeId); return false; } return true; } if (updatetype == UpdateTypes.UPDATETYPE_OUT_OF_RANGE_OBJECTS || updatetype == UpdateTypes.UPDATETYPE_NEAR_OBJECTS) { uint objects_count = gr.ReadUInt32(); if (objects_count > 1000) // we read packet wrong way { long pos = gr.BaseStream.Position; swe.WriteLine("error position " + pos.ToString("X2")); swe.WriteLine("Too many " + updatetype + " objects"); return false; } sb.AppendLine("guids_count " + objects_count); for(uint i = 0; i < objects_count; i++) sb.AppendLine("Guid" + i + ": " + gr.ReadPackedGuid()); return true; } return true; }