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 override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt32();
m_Credits = reader.ReadUShort();
}
void ReadMetadata()
{
_r.BaseStream.Seek(0x50, SeekOrigin.Begin);
var fileCount = _r.ReadInt32();
_r.BaseStream.Seek(0x80, SeekOrigin.Begin);
_files = _r.ReadTArray <FileMetadata>(fileCount * 8, fileCount);
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt32();
switch (version)
{
case 0:
{
break;
}
}
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt32();
switch (version)
{
case 0:
{
break;
}
}
}
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;
}
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)));
}
void ReadMetadata()
{
_r.BaseStream.Seek(0x50, SeekOrigin.Begin);
var fileCount = _r.ReadInt32();
_r.BaseStream.Seek(0x80, SeekOrigin.Begin);
_files = new List <FileMetadata>();
var chunk = new byte[8];
// read in 16 bytes chunks
for (var i = 0; i < fileCount; i++)
{
_r.Read(chunk, 0, 8);
_files.Add(new FileMetadata
{
Position = BitConverter.ToInt32(chunk, 0),
Path = $"{i}",
Size = BitConverter.ToInt32(chunk, 4),
});
}
// files by path
_filesByPath = _files.ToLookup(x => x.Path, StringComparer.OrdinalIgnoreCase);
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt32();
}
/// <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>
/// 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>
/// 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));
}
void Init()
{
if (!File.Exists(WOW_EXE_NAME))
{
Console.WriteLine("{0} not found!", WOW_EXE_NAME);
Console.ReadKey();
return;
}
STREAM = new StreamReader(WOW_EXE_NAME, Encoding.ASCII).ReadToEnd();
gr = new GenericReader(WOW_EXE_NAME, Encoding.ASCII);
Console.WriteLine("{0} kb readed to filestream", gr.BaseStream.Length / 1024);
gr.BaseStream.Position = GO_DATA_INFO_START;
for (int i = 0; i < 128; ++i)
{
GameObjectDataNameInfo info = gr.ReadStruct<GameObjectDataNameInfo>();
m_GoDataNames.Add(info);
}
gr.BaseStream.Position = GO_TYPE_INFO_START;
for (int i = 0; i < 36; ++i)
{
GameObjectTypeInfo info = gr.ReadStruct<GameObjectTypeInfo>();
m_GoTypes.Add(info);
m_GoData.Add(new List<int>());
if (info.DataCount > 0)
{
long pos = gr.BaseStream.Position;
gr.BaseStream.Position = info.DataListOffset - OFFSET2;
for (int j = 0; j < info.DataCount; ++j)
{
int dataid = gr.ReadInt32();
m_GoData[i].Add(dataid);
}
gr.BaseStream.Position = pos;
}
}
DumpToFile();
gr.Close();
Console.WriteLine("Done!");
Console.ReadKey();
}
private static bool ParseValuesUpdateBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data, ObjectTypes objectTypeId, UpdateTypes updatetype, WoWObject obj)
{
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);
int[] updatemask = new int[blocks_count]; // create array of update blocks
for (int j = 0; j < blocks_count; j++)
{
updatemask[j] = gr.ReadInt32(); // populate array of update blocks with data
}
Mask = new BitArray(updatemask);
int reallength = Mask.Count; // bitmask size (bits)
int bitmask_max_size = 0;
uint values_end = 0;
switch (objectTypeId)
{
case ObjectTypes.TYPEID_ITEM:
bitmask_max_size = 64;
values_end = UpdateFieldsLoader.ITEM_END;
break;
case ObjectTypes.TYPEID_CONTAINER:
bitmask_max_size = 160;
values_end = UpdateFieldsLoader.CONTAINER_END;
break;
case ObjectTypes.TYPEID_UNIT:
bitmask_max_size = 256;
values_end = UpdateFieldsLoader.UNIT_END;
break;
case ObjectTypes.TYPEID_PLAYER:
bitmask_max_size = 1536; // 2.3.2 - 1472
values_end = UpdateFieldsLoader.PLAYER_END;
break;
case ObjectTypes.TYPEID_GAMEOBJECT:
bitmask_max_size = 32;
values_end = UpdateFieldsLoader.GO_END;
break;
case ObjectTypes.TYPEID_DYNAMICOBJECT:
bitmask_max_size = 32;
values_end = UpdateFieldsLoader.DO_END;
break;
case ObjectTypes.TYPEID_CORPSE:
bitmask_max_size = 64;
values_end = UpdateFieldsLoader.CORPSE_END;
break;
}
if (reallength > bitmask_max_size)
{
long pos = gr.BaseStream.Position;
swe.WriteLine("error position {0}", pos.ToString("X2"));
swe.WriteLine("error while parsing {0} values update block, count {1}", objectTypeId, reallength);
return(false);
}
for (int index = 0; index < reallength; index++)
{
if (index > values_end)
{
break;
}
if (Mask[index])
{
UpdateField uf = new UpdateField();
switch (objectTypeId)
{
case ObjectTypes.TYPEID_ITEM:
case ObjectTypes.TYPEID_CONTAINER:
uf = UpdateFieldsLoader.item_uf[index];
break;
case ObjectTypes.TYPEID_UNIT:
case ObjectTypes.TYPEID_PLAYER:
uf = UpdateFieldsLoader.unit_uf[index];
break;
case ObjectTypes.TYPEID_GAMEOBJECT:
uf = UpdateFieldsLoader.go_uf[index];
break;
case ObjectTypes.TYPEID_DYNAMICOBJECT:
uf = UpdateFieldsLoader.do_uf[index];
break;
case ObjectTypes.TYPEID_CORPSE:
uf = UpdateFieldsLoader.corpse_uf[index];
break;
}
ReadAndDumpField(uf, sb, gr, updatetype, data, obj);
}
}
if ((objectTypeId == ObjectTypes.TYPEID_GAMEOBJECT || objectTypeId == ObjectTypes.TYPEID_UNIT) && (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) && obj.IsNew)
{
obj.Save();
}
sb.AppendLine("=== values_update_block_end ===");
return(true);
}
