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();
}
