private bool BuildMCNK(BinaryReader reader)
{
try
{
foreach (var chunkInformation in ChunkInformation)
{
reader.BaseStream.Position = chunkInformation.offset;
var dataHeader = new DataChunkHeader(reader);
if (dataHeader.Token != Tokens.MCNK)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MCNK]"}");
}
var dataChunk = reader.ReadBytes(dataHeader.Size);
MapChunks.Add(new SMChunk(dataChunk));
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool ReadMPHD()
{
try
{
var dataHeader = new DataChunkHeader(this);
if (dataHeader.Token != Tokens.MPHD)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MPHD]"}.");
}
var byteChunk = this.ReadBytes(dataHeader.Size);
SMOHeader = new SMOHeader(byteChunk);
if (Globals.Verbose)
{
Console.WriteLine($"[MPHD] Success.");
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
public bool ReadMONM() // MapObjNames
{
try
{
var dataHeader = new DataChunkHeader(this);
if (dataHeader.Token != Tokens.MONM)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MONM]"}.");
}
if (dataHeader.Size > 0)
{
long final_position = this.BaseStream.Position + dataHeader.Size;
while (this.BaseStream.Position < final_position)
{
MapObjectsNames.Add(this.ReadCString());
}
}
if (Globals.Verbose)
{
Console.WriteLine($"Loaded {MapObjectsNames.Count} MapObjectsNames.");
Console.WriteLine($"[MONM] Success.");
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool ReadMVER()
{
try
{
var dataHeader = new DataChunkHeader(this);
if (dataHeader.Token != Tokens.MVER)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MVER]"}");
}
ADTVersion = this.ReadUInt32();
if (Globals.Verbose)
{
Console.WriteLine($"[MVER] Success.");
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool ReadMAIN()
{
try
{
var dataHeader = new DataChunkHeader(this);
if (dataHeader.Token != Tokens.MAIN)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MAIN]"}");
}
var byteChunk = this.ReadBytes(dataHeader.Size);
SMAreaChunks = SMAreaInfo.BuildFromChunk(byteChunk);
if (Globals.Verbose)
{
Console.WriteLine($"Loaded {SMAreaChunks.Length} MapAreaChunks");
Console.WriteLine($"[MAIN] Success.");
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
public CMapArea(uint offset, BinaryReader reader, DataChunkHeader dataChunkHeader)
{
DataChunkHeader = dataChunkHeader;
// MHDR offset
reader.SetPosition(offset);
// AreaHeader
if (!BuildAreaHeader(reader))
{
return;
}
// MCIN, 256 Entries, so a 16*16 Chunkmap.
if (!BuildMCIN(reader))
{
return;
}
// MTEX, List of textures used for texturing the terrain in this map tile.
if (!BuildMTEX(reader))
{
return;
}
// MDDF, Placement information for doodads (M2 models)
// Additional to this, the models to render are referenced in each MCRF chunk.
if (!BuildMDDF(reader))
{
return;
}
// MODF, Placement information for WMOs.
// Additional to this, the WMOs to render are referenced in each MCRF chunk.
if (!BuildMODF(reader))
{
return;
}
// The MCNK chunks have a large block of data that starts with a header, and then has sub-chunks of its own.
// Each map chunk has 9x9 vertices, and in between them 8x8 additional vertices, several texture layers, normal vectors,
// a shadow map, etc.
// MCNK, The header is 128 bytes like later versions, but information inside is placed slightly differently.
// Offsets are relative to the end of MCNK header.
if (!BuildMCNK(reader))
{
return;
}
Errors = false;
}
public void Dispose()
{
AreaHeader = null;
MTEXChunk = null;
DoodadRefs = null;
SMMapObjDefs = null;
TilesInformation = null;
foreach (var tile in Tiles)
{
tile.Dispose();
}
Tiles = null;
DataChunkHeader = null;
}
protected override void Dispose(bool disposing)
{
DBCMap = null;
Name = string.Empty;
SMOHeader = null;
TileBlocksInformation = null;
DoodadsNames.Clear();
DoodadsNames = null;
MapObjectsNames.Clear();
MapObjectsNames = null;
MODF = null;
TileBlocks = null;
DataChunkHeader = null;
base.Dispose(disposing);
}
/// <summary>
/// TODO
/// </summary>
private void BuildMCLY(BinaryReader reader, uint offset)
{
reader.SetPosition(offset + HeaderOffsetEnd);
if (reader.IsEOF())
{
return;
}
var dataHeader = new DataChunkHeader(reader);
if (dataHeader.Token != Tokens.MCLY)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MCLY]"}");
}
reader.ReadBytes(dataHeader.Size);
}
private bool ReadMODF()
{
try
{
var dataHeader = new DataChunkHeader(this);
if (dataHeader.Token == Tokens.MODF)
{
MODF = new SMMapObjDef(this);
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool BuildAreaHeader(BinaryReader reader)
{
try
{
var dataHeader = new DataChunkHeader(reader);
if (dataHeader.Token != Tokens.MHDRChunk)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MHDRChunk]"}");
}
AreaHeader = new SMAreaHeader(reader);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool BuildMCIN(BinaryReader reader)
{
try
{
var dataHeader = new DataChunkHeader(reader);
if (dataHeader.Token != Tokens.MCIN)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MCIN]"}");
}
var dataChunk = reader.ReadBytes(dataHeader.Size);
ChunkInformation = SMChunkInfo.BuildFromChunk(dataChunk);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool BuildMDDF(BinaryReader reader)
{
try
{
var dataHeader = new DataChunkHeader(reader);
if (dataHeader.Token != Tokens.MDDF)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MDDF]"}");
}
var dataChunk = reader.ReadBytes(dataHeader.Size);
DoodadRefs = SMDoodadDef.BuildFromChunck(dataChunk);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
private bool BuildMODF(BinaryReader reader)
{
try
{
var dataHeader = new DataChunkHeader(reader);
if (dataHeader.Token != Tokens.MODF)
{
throw new Exception($"Invalid token, got [{dataHeader.Token}] expected {"[MODF]"}");
}
//MODF (Placement information for WMOs. Additional to this, the WMOs to render are referenced in each MCRF chunk)
var dataChunk = reader.ReadBytes(dataHeader.Size);
SMMapObjDefs = SMMapObjDef.BuildFromChunk(dataChunk);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(false);
}
