public void Read()
{
foreach (var subChunk in Data.Chunks)
{
switch (subChunk.Name)
{
case "MAIN":
MAIN = new MAIN(subChunk);
IsValid = true;
TileTable = new bool[64, 64];
for (int y = 0; y < 64; y++)
{
for (int x = 0; x < 64; x++)
{
TileTable[x, y] = MAIN.Entries[x, y].Flags.HasFlag(MAIN.MAINFlags.HasADT);
}
}
break;
case "MWMO":
MWMO = new MWMO(subChunk);
break;
case "MODF":
MODF = new MODF(subChunk);
break;
}
}
IsGlobalModel = (MODF != null && MWMO != null);
}
public void Read()
{
if (Type == ADTType.Normal)
{
ADTObjects = new ADT(World, X, Y, ADTType.Objects);
ADTObjects.Read();
//ADTTextures = new ADT(World, X, Y, ADTType.Textures);
//ADTTextures.Read();
}
MapChunks = new MapChunk[16 * 16];
int mcIdx = 0;
foreach (var subChunk in Data.Chunks)
{
switch (subChunk.Name)
{
case "MHDR":
MHDR = new MHDR(subChunk);
break;
case "MMDX":
MMDX = new MMDX(subChunk);
break;
case "MMID":
MMID = new MMID(subChunk);
ReadDoodads();
break;
case "MWMO":
MWMO = new MWMO(subChunk);
break;
case "MWID":
MWID = new MWID(subChunk);
ReadModels();
break;
case "MDDF":
MDDF = new MDDF(subChunk);
break;
case "MODF":
MODF = new MODF(subChunk);
break;
case "MH2O":
Liquid = new LiquidChunk(this, subChunk);
break;
case "MCNK":
MapChunks[mcIdx++] = new MapChunk(this, subChunk);
break;
}
}
}
private MODF ReadMODFChunk(uint size, BinaryReader bin)
{
MODF modf = new MODF();
var count = size / 64;
modf.entries = new MODFEntry[count];
for (int i = 0; i < count; i++)
{
modf.entries[i] = bin.Read <MODFEntry>();
}
return(modf);
}
private MODF ReadMODFChunk(BlizzHeader chunk, BinaryReader bin)
{
MODF modf = new MODF();
var count = chunk.Size / 64; //64 bytes per entry?
// Console.WriteLine(count + " MODF entries!");
modf.entries = new MODFEntry[count];
for (int i = 0; i < count; i++)
{
modf.entries[i] = bin.Read <MODFEntry>();
}
return(modf);
}
private MODF ReadMODFChunk(uint size, BinaryReader bin)
{
var modf = new MODF();
var count = size / 64;
modf.entries = new MODFEntry[count];
for (var i = 0; i < count; i++)
{
modf.entries[i] = bin.Read <MODFEntry>();
if (modf.entries[i].flags.HasFlag(MODFFlags.modf_entry_is_filedataid))
{
Console.WriteLine("ADT Reader: Found a filedataid reference while parsing MODF: {0}", modf.entries[i].mwidEntry);
}
}
return(modf);
}
public OBJ0(Files.WOTLK.ADT wotlk)
{
ADTfileInfo = new FileInfo(wotlk.ADTfileInfo.Name.Split('.')[0] + "_obj0.adt");
Logger.log(ADTfileInfo.Name, Logger.Type.CONVERT, "<- " + wotlk.ADTfileInfo.Name);
MVER = new MVER(wotlk.MVER);
MMDX = new MMDX(wotlk.MMDX);
MMID = new MMID(wotlk.MMID);
MWMO = new MWMO(wotlk.MWMO);
MWID = new MWID(wotlk.MWID);
MDDF = new MDDF(wotlk.MDDF);
MODF = new MODF(wotlk.MODF);
foreach (Files.WOTLK.Chunks.MCNK x in wotlk.MCNKs)
{
MCNKs.Add(new MCNK_OBJ0(x));
MCNKLength += MCNKs[MCNKs.Count - 1].GetBytes().Length;
}
Logger.log("MCNK[]", Logger.Type.LEVEL1);
}
public WDT(IBinaryReader reader)
{
int chunkId = 0;
Dictionary <int, string>?mwmosNameOffsets = null;
while (!reader.IsFinished())
{
var chunkName = reader.ReadChunkName();
var size = reader.ReadInt32();
var offset = reader.Offset;
var partialReader = new LimitedReader(reader, size);
if (chunkName == "MVER")
{
Version = reader.ReadUInt32();
}
else if (chunkName == "MPHD")
{
Header = WDTHeader.Read(partialReader);
}
else if (chunkName == "MAIN")
{
Chunks[chunkId++] = new WDTChunk(partialReader);
}
else if (chunkName == "MWMO")
{
Mwmo = ChunkedUtils.ReadZeroTerminatedStringArrays(partialReader, true, out mwmosNameOffsets)[0];
}
else if (chunkName == "MODF")
{
WorldMapObject = MODF.Read(partialReader);
}
reader.Offset = offset + size;
}
}
public ADT(string filePath)
{
ADTfileInfo = new FileInfo(filePath);
Logger.log(ADTfileInfo.Name, Logger.Type.READ, ADTfileInfo.DirectoryName);
//Start reading the .ADT File
using (BinaryReader reader = new BinaryReader(ADTfileInfo.Open(FileMode.Open)))
{
Length = (int)reader.BaseStream.Length;
reader.BaseStream.Seek(0, SeekOrigin.Begin);
int MCNK_counter = 0;
int MCNK_size = 0;
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
byte[] ChunkMagic = reader.ReadBytes(4);
byte[] ChunkSize = reader.ReadBytes(4);
byte[] ChunkContent = reader.ReadBytes(BitConverter.ToInt32(ChunkSize, 0));
string ChunkMagicString = MagicBytesToString(ChunkMagic);
//read the chunks
switch (ChunkMagicString)
{
case "MVER":
MVER = new MVER(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MHDR":
MHDR = new MHDR(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MCIN":
MCIN = new MCIN(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MTEX":
MTEX = new MTEX(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MMDX":
MMDX = new MMDX(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MMID":
MMID = new MMID(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MWMO":
MWMO = new MWMO(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MWID":
MWID = new MWID(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MDDF":
MDDF = new MDDF(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MODF":
MODF = new MODF(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MH2O":
MH2O = new MH2O(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
case "MCNK":
MCNKs.Add(new MCNK(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent));
break;
case "MFBO":
MFBO = new MFBO(MagicBytesToChars(ChunkMagic), ChunkSize, ChunkContent);
break;
}
if (ChunkMagicString == "MCNK")
{
MCNK_counter++; MCNK_size += BitConverter.ToInt32(ChunkSize, 0);
}
else if (ChunkMagicString == "\0\0\0\0") /*Logger.log("0 Byte Chunk", Logger.Direction.WARNING);*/ } {
}
if (MCNK_counter > 0)
{
Logger.log("MCNK[]", Logger.Type.LEVEL1, MCNK_size + " byte");
}
}
}
public void Write()
{
using (var writer = new BinaryWriter(File.OpenWrite("test.adt")))
{
// MVER
writer.Write(MVER.GetChunkHeaderBytes());
writer.Write(MVER.GetChunkBytes());
// Write MHDR later when we got all offsets
var positionBeforeMHDR = writer.BaseStream.Position;
writer.BaseStream.Position += _HeaderSize + MHDR.ChunkSize;
// MTEX
MHDR.OffsetMTEX = (uint)writer.BaseStream.Position;
writer.Write(MTEX.GetChunkHeaderBytes());
writer.Write(MTEX.GetChunkBytes());
// MMDX
MHDR.OffsetMMDX = (uint)writer.BaseStream.Position;
writer.Write(MMDX.GetChunkHeaderBytes());
writer.Write(MMDX.GetChunkBytes());
// MMID
MHDR.OffsetMMID = (uint)writer.BaseStream.Position;
writer.Write(MMID.GetChunkHeaderBytes());
writer.Write(MMID.GetChunkBytes());
// MWMO
MHDR.OffsetMWMO = (uint)writer.BaseStream.Position;
writer.Write(MWMO.GetChunkHeaderBytes());
writer.Write(MWMO.GetChunkBytes());
// MWID
MHDR.OffsetMWID = (uint)writer.BaseStream.Position;
writer.Write(MWID.GetChunkHeaderBytes());
writer.Write(MWID.GetChunkBytes());
// MDDF
MHDR.OffsetMDDF = (uint)writer.BaseStream.Position;
writer.Write(MDDF.GetChunkHeaderBytes());
writer.Write(MDDF.GetChunkBytes());
// MODF
MHDR.OffsetMODF = (uint)writer.BaseStream.Position;
writer.Write(MODF.GetChunkHeaderBytes());
writer.Write(MODF.GetChunkBytes());
// MH2O
MHDR.OffsetMH2O = (uint)writer.BaseStream.Position;
writer.Write(MH2O.GetChunkHeaderBytes());
writer.Write(MH2O.GetChunkBytes());
// MCNK
for (int i = 0; i < MCIN.Entries.Length; i++)
{
MCIN.Entries[i].OffsetMCNK = (uint)writer.BaseStream.Position;
MCIN.Entries[i].ChunkSize = MCNK[i].ChunkSize;
writer.Write(MCNK[i].GetChunkHeaderBytes());
writer.Write(MCNK[i].GetChunkBytes());
}
// MCIN
MHDR.OffsetMCIN = (uint)writer.BaseStream.Position;
writer.Write(MCIN.GetChunkHeaderBytes());
writer.Write(MCIN.GetChunkBytes());
// MFBO
if (MHDR.Flags.HasFlag(MHDRFlags.MFBO))
{
MHDR.OffsetMFBO = (uint)writer.BaseStream.Position;
writer.Write(MFBO.GetChunkHeaderBytes());
writer.Write(MFBO.GetChunkBytes());
}
else
{
MHDR.OffsetMFBO = 0;
}
// MTXF
MHDR.OffsetMTXF = (uint)writer.BaseStream.Position;
writer.Write(MTXF.GetChunkHeaderBytes());
writer.Write(MTXF.GetChunkBytes());
// MHDR
writer.BaseStream.Position = positionBeforeMHDR;
writer.Write(MHDR.GetChunkHeaderBytes());
writer.Write(MHDR.GetChunkBytes());
}
}
