public virtual void Deserialize(GenericReader reader) { var version = reader.GetVersion(); ProviderID = reader.ReadInt(); switch (version) { case 2: { Value = reader.ReadString(); _ValueHash = reader.ReadInt(); } break; case 1: { var seed = reader.ReadBool() ? StringCompression.Unpack(reader.ReadBytes()) : Encoding.UTF32.GetString(reader.ReadBytes()); Value = CryptoGenerator.GenString(ProviderID, seed ?? String.Empty); } break; case 0: { var seed = reader.ReadString(); Value = CryptoGenerator.GenString(ProviderID, seed ?? String.Empty); } break; } }
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 static GenericReader Decompress(GenericReader gr) { int uncompressedLength = gr.ReadInt32(); byte[] input = gr.ReadBytes((int)gr.Remaining); byte[] output = new byte[uncompressedLength]; gr.Close(); InflaterInputStream istream = new InflaterInputStream(new MemoryStream(input)); int offset = 0; while (true) { int size = istream.Read(output, offset, uncompressedLength); if (size == uncompressedLength) { break; } offset += size; uncompressedLength -= size; } return(new GenericReader(new MemoryStream(output))); }
public static void Decompress(ref GenericReader gr) { int uncompressedLength = gr.ReadInt32(); byte[] output = new byte[gr.ReadInt32()]; byte[] temp = gr.ReadBytes((int)gr.Remaining); gr.Close(); Stream s = new InflaterInputStream(new MemoryStream(temp)); int offset = 0; while (true) { int size = s.Read(output, offset, uncompressedLength); if (size == uncompressedLength) { break; } offset += size; uncompressedLength -= size; } gr = new GenericReader(new MemoryStream(output)); //gr.BaseStream.Position = 0; }
/// <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); }
/// <summary> /// Loads an archived file's data. /// </summary> Task <byte[]> LoadFileDataAsync(FileMetadata file) { var fileSize = (int)file.Size; byte[] fileData; bool bsaCompressed; int newFileSize; lock (_r) { _r.Position = file.Offset; if (_hasNamePrefix) { var len = _r.ReadByte(); fileSize -= len + 1; _r.Position = file.Offset + 1 + len; } fileData = _r.ReadBytes(fileSize); bsaCompressed = file.SizeFlags > 0 && file.Compressed ^ _compressToggle; newFileSize = Version == SSE_BSAHEADER_VERSION && bsaCompressed?_r.ReadInt32() - 4 : fileSize; } // BSA if (bsaCompressed) { var newFileData = new byte[newFileSize]; if (Version != SSE_BSAHEADER_VERSION) { if (fileData.Length > 4) { using (var s = new MemoryStream(fileData, 4, fileSize - 4)) using (var gs = new InflaterInputStream(s)) gs.Read(newFileData, 0, newFileData.Length); } else { newFileData = fileData; } } else { using (var s = new MemoryStream(fileData)) using (var gs = new LzwInputStream(s)) gs.Read(newFileData, 0, newFileData.Length); } fileData = newFileData; } // General BA2 else if (file.PackedSize > 0 && file.Tex.Chunks == null) { var newFileData = new byte[file.UnpackedSize]; using (var s = new MemoryStream(fileData)) using (var gs = new InflaterInputStream(s)) gs.Read(newFileData, 0, newFileData.Length); fileData = newFileData; } // Fill DDS Header else if (file.Tex.Chunks != null) { // Fill DDS Header var ddsHeader = new DDSHeader { dwFlags = DDSFlags.HEADER_FLAGS_TEXTURE | DDSFlags.HEADER_FLAGS_LINEARSIZE | DDSFlags.HEADER_FLAGS_MIPMAP, dwHeight = file.Tex.Height, dwWidth = file.Tex.Width, dwMipMapCount = file.Tex.NumMips, dwCaps = DDSCaps.SURFACE_FLAGS_TEXTURE | DDSCaps.SURFACE_FLAGS_MIPMAP, dwCaps2 = file.Tex.Unk16 == 2049 ? DDSCaps2.CUBEMAP_ALLFACES : 0, }; var dx10Header = new DDSHeader_DXT10(); var dx10 = false; // map tex format switch (file.Tex.Format) { case DXGIFormat.BC1_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.FourCC; ddsHeader.ddspf.dwFourCC = Encoding.ASCII.GetBytes("DXT1"); ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height / 2U; // 4bpp break; case DXGIFormat.BC2_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.FourCC; ddsHeader.ddspf.dwFourCC = Encoding.ASCII.GetBytes("DXT3"); ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height; // 8bpp break; case DXGIFormat.BC3_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.FourCC; ddsHeader.ddspf.dwFourCC = Encoding.ASCII.GetBytes("DXT5"); ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height; // 8bpp break; case DXGIFormat.BC5_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.FourCC; ddsHeader.ddspf.dwFourCC = Encoding.ASCII.GetBytes("ATI2"); ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height; // 8bpp break; case DXGIFormat.BC7_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.FourCC; ddsHeader.ddspf.dwFourCC = Encoding.ASCII.GetBytes("DX10"); ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height; // 8bpp dx10 = true; dx10Header.dxgiFormat = DXGIFormat.BC7_UNORM; break; case DXGIFormat.DXGI_FORMAT_B8G8R8A8_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.RGB | DDSPixelFormats.AlphaPixels; ddsHeader.ddspf.dwRGBBitCount = 32; ddsHeader.ddspf.dwRBitMask = 0x00FF0000; ddsHeader.ddspf.dwGBitMask = 0x0000FF00; ddsHeader.ddspf.dwBBitMask = 0x000000FF; ddsHeader.ddspf.dwABitMask = 0xFF000000; ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height * 4; // 32bpp break; case DXGIFormat.DXGI_FORMAT_R8_UNORM: ddsHeader.ddspf.dwFlags = DDSPixelFormats.RGB; ddsHeader.ddspf.dwRGBBitCount = 8; ddsHeader.ddspf.dwRBitMask = 0xFF; ddsHeader.dwPitchOrLinearSize = (uint)file.Tex.Width * file.Tex.Height; // 8bpp break; default: throw new InvalidOperationException("DDS FAILED"); } if (dx10) { dx10Header.resourceDimension = DDSDimension.Texture2D; dx10Header.miscFlag = 0; dx10Header.arraySize = 1; dx10Header.miscFlags2 = 0; dx10Header.Write(null); //char dds2[sizeof(dx10Header)]; //memcpy(dds2, &dx10Header, sizeof(dx10Header)); //content.append(QByteArray::fromRawData(dds2, sizeof(dx10Header))); } } return(Task.FromResult(fileData)); }
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(); }