Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

World of Warcraft WDT Format Documentation

Validation Status: This documentation has been validated against 100 real WDT files from WoW versions 1.12.1 through 5.4.8, achieving 100% parsing success rate.

Table of Contents

Introduction

WDT (World Data Table) files are fundamental components of World of Warcraft’s world rendering system. They serve as master indexes that define which map tiles (ADT files) exist in a world and can optionally reference a global World Map Object (WMO) for WMO-only maps like instances.

Purpose and Overview

WDT files serve several critical functions:

  1. Map Tile Presence: Define which of the potential 64×64 ADT tiles actually exist for a given map - ✅ Implemented
  2. Global WMO Reference: For indoor/instance maps, reference a single global WMO - ✅ Implemented
  3. Map Properties: Store various flags and properties that affect how the entire map is rendered - ✅ Implemented
  4. Lighting Information: Define global lighting properties and light sources - ⚠️ Format Specification Only
  5. Fog Effects: Control volumetric fog and atmospheric effects - ⚠️ Format Specification Only
  6. Occlusion Data: Provide low-resolution occlusion information for improved rendering performance - ⚠️ Format Specification Only

File Structure

WDT files follow the standard chunked format used by many WoW file types:

#![allow(unused)]
fn main() {
struct IffChunk {
    magic: [u8; 4],    // Chunk identifier (e.g., "MVER", "MPHD")
    size: u32,         // Size of chunk data in bytes
    data: Vec<u8>,     // Chunk-specific data
}
}

Coordinate Systems

World of Warcraft uses different coordinate systems for different file types and purposes. Understanding these systems is crucial for correctly parsing and rendering WDT data, especially when dealing with WMO placement.

ADT/WDT Terrain Coordinate System

The terrain system uses a right-handed coordinate system:

  • X-axis: Points North (decreasing tile Y)
  • Y-axis: Points West (decreasing tile X)
  • Z-axis: Points Up (vertical height)
  • Origin: Map center at tile [32, 32]
  • Range: ±17066.666 world units on X and Y axes

In vector notation: position = Vector3.Forward * x + Vector3.Left * y + Vector3.Up * z

M2/WMO Model Coordinate System

Models use a right-handed coordinate system with inverted horizontal axes:

  • X-axis: Points North
  • Y-axis: Points West
  • Z-axis: Points Up

In vector notation: position = Vector3.Backward * x + Vector3.Right * y + Vector3.Up * z

This means model space has inverted X and Y compared to terrain space.

MDDF/MODF Placement Coordinate System

Placement chunks use a right-handed coordinate system with completely different axis orientation:

  • X-axis: Points West
  • Y-axis: Points Up (vertical)
  • Z-axis: Points North

Important transformations for MODF placement:

#![allow(unused)]
fn main() {
// Convert from placement coordinates to world coordinates
let world_x = 32.0 * TILESIZE - placement_x;
let world_z = 32.0 * TILESIZE - placement_z;
let world_y = placement_y; // Y (up) remains the same
}

Rotation order (Euler angles):

  1. X rotation: Around West/East axis
  2. Y rotation: Around Up axis
  3. Z rotation: Around North/South axis

Blender Coordinate System

For exporting to Blender:

  • Right-handed, Z-up system
  • Right = (1,0,0), Forward = (0,1,0), Up = (0,0,1)

Conversion from WoW to Blender:

#![allow(unused)]
fn main() {
// WoW terrain to Blender
blender_x = wow_x;      // North
blender_y = -wow_y;     // East (inverted from West)
blender_z = wow_z;      // Up

// WoW MODF rotation to Blender (example)
// Requires careful handling of rotation order and axis mapping
}

Key Concepts

  1. Handedness: All WoW coordinate systems are right-handed
  2. Units: 1 unit = 1 yard in game world
  3. Tile Size: Each ADT tile is 533.33333 units
  4. Map Size: 64×64 tiles = 34133.333 units total
  5. Array Ordering: Tile arrays use [Y][X] ordering (row-major)

Common Pitfalls

  1. Array vs World: Tile arrays are indexed [Y][X] but world coordinates are (X, Y, Z)
  2. Rotation Units: Always radians in files (beware of 2.4.3 DireMaul bug using degrees)
  3. Model Placement: MODF coordinates need transformation to world space
  4. Left-handed Renderers: Negate all rotations when converting to left-handed systems

Typical Chunk Order

For main WDT files:

  1. MVER - Version information (always first, version 18 across all tested versions)
  2. MPHD - Map header with flags and file references
  3. MAIN - Map tile presence information
  4. MAID - FileDataIDs for ADT files (post-8.1)
  5. MWMO - Global WMO filename (WMO-only maps have data; pre-4.x terrain maps have empty chunk; 4.x+ terrain maps have NO chunk)
  6. MODF - Global WMO placement (WMO-only maps with HasTerrain flag)

For auxiliary WDT files:

  • _lgt.wdt: MVER, MPL2/MPL3, MSLT, MTEX, MLTA
  • _occ.wdt: MVER, MAOI, MAOH
  • _fogs.wdt: MVER, MVFX, VFOG, VFEX
  • _tex.wdt: MVER, MTXF, MTXP (if present)

Chunk Specifications

MVER - Version

The version chunk is always the first chunk in the file.

#![allow(unused)]
fn main() {
struct MVER {
    version: u32,  // Always 18 for WDT files
}
}

MPHD - Map Header

Contains global flags and references to other map-related files.

#![allow(unused)]
fn main() {
struct MPHD {
    flags: u32,              // See flag definitions below

    // Pre-8.1.0 (Classic through Legion):
    something: u32,          // Unknown purpose
    unused: [u32; 6],        // Reserved (always 0)
    // Total size: 32 bytes

    // Post-8.1.0 (BfA+):
    // The 7 uint32 fields above are repurposed as FileDataIDs:
    lgt_file_data_id: u32,   // _lgt.wdt lighting file
    occ_file_data_id: u32,   // _occ.wdt occlusion file
    fogs_file_data_id: u32,  // _fogs.wdt fog file
    mpv_file_data_id: u32,   // _mpv.wdt particulate volume file
    tex_file_data_id: u32,   // _tex.wdt texture file
    wdl_file_data_id: u32,   // _wdl low-resolution heightmap
    pd4_file_data_id: u32,   // _pd4.wdt file
}
}

Important: The presence of specific chunks depends on the MPHD flags:

  • Maps with flag 0x0001 (HasTerrain/WdtUsesGlobalMapObj) will have MWMO and MODF chunks
  • Maps without this flag are terrain-based and may not have MWMO/MODF chunks

MPHD Flags

#![allow(unused)]
fn main() {
enum MphdFlags {
    WdtUsesGlobalMapObj              = 0x0001,  // Map is WMO-only (UsesGlobalModels)
    AdtHasMccv                       = 0x0002,  // ADTs have vertex colors (UsesVertexShading)
    AdtHasBigAlpha                   = 0x0004,  // Alternative terrain shader (UsesEnvironmentMapping)
    AdtHasDoodadrefsSortedBySizeCat  = 0x0008,  // Doodads sorted by size (DisableUnknownRenderingFlag)
    AdtHasLightingVertices           = 0x0010,  // ADTs have MCLV chunk (UsesVertexLighting, deprecated in 8.x)
    AdtHasUpsideDownGround           = 0x0020,  // Flip ground display (FlipGroundNormals)
    UnkFirelands                     = 0x0040,  // Universal in 4.3.4+ (all maps have this)
    AdtHasHeightTexturing            = 0x0080,  // Use _h textures (UsesHardAlphaFalloff)
    UnkLoadLod                       = 0x0100,  // Load _lod.adt files (UnknownHardAlphaRelated)
    WdtHasMaid                       = 0x0200,  // Has MAID chunk with FileDataIDs (8.1.0+)
    UnkFlag0x0400                    = 0x0400,  // Unknown
    UnkFlag0x0800                    = 0x0800,  // Unknown
    UnkFlag0x1000                    = 0x1000,  // Unknown
    UnkFlag0x2000                    = 0x2000,  // Unknown
    UnkFlag0x4000                    = 0x4000,  // Unknown
    UnkFlag0x8000                    = 0x8000,  // Unknown (UnknownContinentRelated)
}
}

MAIN - Map Area Information

Defines which ADT tiles exist in the 64×64 grid.

#![allow(unused)]
fn main() {
struct MAIN {
    entries: [[MainEntry; 64]; 64],  // [y][x] ordering
}

struct MainEntry {
    flags: u32,     // See flag definitions below
    area_id: u32,   // AreaTable.dbc ID (async loading in 0.5.3+)
}

enum MainFlags {
    HasAdt      = 0x0001,  // ADT file exists for this tile (HasTerrainData in libwarcraft)
    IsLoaded    = 0x0002,  // Set at runtime when ADT is loaded (never stored in file)
    AllWater    = 0x0002,  // Special flag for all-water tiles (runtime only)
    IsImported  = 0x0004,  // Marks imported tiles (runtime only)
    // Note: Flags 0x0002 and 0x0004 are runtime-only and not stored in the file
}
}

MAID - Map Area ID

Introduced in 8.1.0, contains FileDataIDs for all map files.

#![allow(unused)]
fn main() {
struct MAID {
    // Each section contains 64x64 entries (4096 uint32 values)
    // Stored in [y][x] order (row-major)

    root_adt: [[u32; 64]; 64],        // FileDataIDs for root ADT files
    obj0_adt: [[u32; 64]; 64],        // FileDataIDs for _obj0.adt files
    obj1_adt: [[u32; 64]; 64],        // FileDataIDs for _obj1.adt files
    tex0_adt: [[u32; 64]; 64],        // FileDataIDs for _tex0.adt files
    lod_adt: [[u32; 64]; 64],         // FileDataIDs for _lod.adt files
    map_texture: [[u32; 64]; 64],     // FileDataIDs for map textures
    map_texture_n: [[u32; 64]; 64],   // FileDataIDs for normal map textures
    minimap_texture: [[u32; 64]; 64], // FileDataIDs for minimap textures

    // Note: The exact structure may vary by version
    // Some versions may include additional sections
}
}

MWMO - World Map Object

For WMO-only maps, contains the filename of the global WMO.

#![allow(unused)]
fn main() {
struct MWMO {
    filename: CString,  // Zero-terminated string, max 256 bytes
}
}

Notes:

  • In MOP, this chunk is limited to 0x100 bytes due to stack allocation
  • Pre-4.x: Both WMO-only and terrain maps have MWMO chunks (terrain maps have 0-byte data)
  • 4.x+ (Cataclysm onwards): Only WMO-only maps have MWMO chunks; terrain maps have NO MWMO chunk
  • Presence correlates with MPHD flag 0x0001 (HasTerrain/WdtUsesGlobalMapObj)

MODF - Map Object Definition

Placement information for the global WMO (if present). Only appears in WMO-only maps (MPHD flag 0x0001 set).

#![allow(unused)]
fn main() {
struct MODF {
    entries: Vec<ModfEntry>,  // Only one entry for WDT files
}

struct ModfEntry {
    id: u32,                  // Index into MWMO, unused in WDT
    unique_id: u32,           // Unique instance ID (0xFFFFFFFF in 1.12.1, 0 in 3.3.5a)
    position: [f32; 3],       // Position in MODF coordinate system (see below)
    rotation: [f32; 3],       // Euler angles in radians (X, Y, Z order)
                              // Note: Some 2.4.3 files incorrectly store degrees
    lower_bounds: [f32; 3],   // Bounding box minimum corner (MODF coordinates)
    upper_bounds: [f32; 3],   // Bounding box maximum corner (MODF coordinates)
    flags: u16,               // WMO flags (see ModfFlags below)
    doodad_set: u16,          // Doodad set index
    name_set: u16,            // Name set index
    scale: u16,               // Scale factor (0 in 1.12.1, 1024 = 1.0 in later versions)
}

// IMPORTANT: MODF uses placement coordinate system!
// To convert MODF position to world coordinates:
// world_x = 32.0 * 533.33333 - modf_position.x
// world_y = modf_position.y
// world_z = 32.0 * 533.33333 - modf_position.z

enum ModfFlags {
    Destructible = 0x0001,    // WMO is destructible
    UseLod       = 0x0002,    // WMO has LOD levels
    Unknown      = 0x0004,    // Unknown flag
}
}

Light-Related Chunks (_lgt.wdt)

These chunks are specific to _lgt.wdt files, introduced in Legion (7.0) for enhanced lighting systems.

MPL2 - Point Light v2

Introduced in Legion, defines point lights with enhanced properties.

#![allow(unused)]
fn main() {
struct MPL2 {
    version: u32,         // Always 18
    entries: Vec<Mpl2Entry>,
}

struct Mpl2Entry {
    id: u32,                      // Unique light ID
    color: [u8; 4],               // BGRA format
    position: [f32; 3],           // X, Y, Z world coordinates
    attenuation_start: f32,       // Light falloff start distance
    attenuation_end: f32,         // Light falloff end distance
    intensity: f32,               // Light intensity multiplier
    unknown: [f32; 3],            // Unknown values
    tile_x: u16,                  // ADT tile X coordinate
    tile_y: u16,                  // ADT tile Y coordinate
    mlta_index: i16,              // Index into MLTA chunk (-1 if unused)
    mtex_index: i16,              // Index into MTEX chunk (-1 if unused)
}
}

MPL3 - Point Light v3

Enhanced version introduced in Shadowlands (9.0) with additional features.

#![allow(unused)]
fn main() {
struct MPL3 {
    version: u32,         // Version number
    entries: Vec<Mpl3Entry>,
}

struct Mpl3Entry {
    // All fields from MPL2, plus:
    flags: u32,                   // Light behavior flags
    scale: f32,                   // Light scale factor
    shadow_flags: u32,            // Shadow casting options
    render_flags: u32,            // Rendering behavior
    // Additional fields may vary by version
}
}

MSLT - Spotlight

Defines directional spotlights with cone properties.

#![allow(unused)]
fn main() {
struct MSLT {
    version: u32,         // Always 18
    entries: Vec<MsltEntry>,
}

struct MsltEntry {
    id: u32,                      // Unique light ID
    color: [u8; 4],               // BGRA format
    position: [f32; 3],           // X, Y, Z world coordinates
    rotation: [f32; 3],           // X, Y, Z rotation (radians)
    attenuation_start: f32,       // Light falloff start
    attenuation_end: f32,         // Light falloff end
    intensity: f32,               // Light intensity
    inner_cone_angle: f32,        // Inner cone angle (radians)
    outer_cone_angle: f32,        // Outer cone angle (radians)
    tile_x: u16,                  // ADT tile X
    tile_y: u16,                  // ADT tile Y
    mlta_index: i16,              // Index into MLTA chunk
    mtex_index: i16,              // Index into MTEX chunk
}
}

MTEX - Texture References

Contains FileDataIDs for textures used by lights (e.g., projected textures).

#![allow(unused)]
fn main() {
struct MTEX {
    texture_file_data_ids: Vec<u32>,  // Array of texture FileDataIDs
}
}

MLTA - Map Light Texture Animation

Defines animation properties for light textures.

#![allow(unused)]
fn main() {
struct MLTA {
    version: u32,         // Version number
    entries: Vec<MltaEntry>,
}

struct MltaEntry {
    amplitude: f32,       // Animation amplitude
    frequency: f32,       // Animation frequency
    function: u32,        // Animation function type
}
}

Occlusion Chunks (_occ.wdt)

MAOI/MAOH - Map Area Occlusion Information

Provides occlusion data for improved rendering performance.

#![allow(unused)]
fn main() {
struct MAOI {
    version: u32,         // Always 18
    entries: Vec<MaoiEntry>,
}

struct MaoiEntry {
    tile_x: u16,          // ADT X coordinate
    tile_y: u16,          // ADT Y coordinate
    offset: u32,          // Offset into MAOH data
    size: u32,            // Always (17*17 + 16*16) * 2
}

struct MAOH {
    data: Vec<u8>,        // Height data for occlusion
}
}

MTXF - Map Texture Flags

Controls texture-related properties.

#![allow(unused)]
fn main() {
struct MTXF {
    version: u32,         // Always 18
    entries: Vec<MtxfEntry>,
}

struct MtxfEntry {
    usage_flags: u32,     // Texture usage flags
    // Additional texture properties
}
}

Fog Chunks (_fogs.wdt)

These chunks are found in _fogs.wdt files, which were added in Legion but became meaningful in Battle for Azeroth.

MVFX - Map Volumetric Fog Effects

References fog effects used in the map.

#![allow(unused)]
fn main() {
struct MVFX {
    version: u32,         // Always 2
    entries: Vec<MvfxEntry>,
}

struct MvfxEntry {
    file_data_id: u32,    // Reference to fog effect file
    // Additional properties may follow
}
}

VFOG - Volumetric Fog

Defines volumetric fog areas and properties.

#![allow(unused)]
fn main() {
struct VFOG {
    version: u32,         // Always 2
    count: u32,
    entries: Vec<VfogEntry>,
}

struct VfogEntry {
    id: u32,
    radius_start: f32,
    radius_end: f32,
    fog_start_multiplier: f32,
    fog_end_multiplier: f32,
    color: [u8; 4],       // RGBA format
    // Additional fog properties
}
}

VFEX - Volumetric Fog Extended

Extended fog data for backwards compatibility (version 2+).

#![allow(unused)]
fn main() {
struct VFEX {
    entries: Vec<VfexEntry>,
}

struct VfexEntry {
    unk0: u32,            // Default 1
    unk1: [f32; 16],      // First 3 floats have values, rest are 1.0
    vfog_id: u32,         // Reference to VFOG entry
    unk3: u32,            // Default 0
    unk4: u32,            // Default 0
    unk5: u32,            // Default 0
    unk6: u32,            // Default 0
    unk7: u32,            // Default 0
    unk8: u32,            // Default 0
}
}

MANM - Map Navigation Mesh (PTR)

Temporarily present during 8.3.0 PTR for navigation/scripting data.

#![allow(unused)]
fn main() {
struct MANM {
    // Structure was not fully reverse-engineered
    // Contains positions and globally unique IDs
    // Often marked roads or walls
}
}

Chunk Evolution Timeline

Based on analysis of WDT files from WoW versions 1.12.1 through 5.4.8:

Core Chunks (Present in all versions)

  • MVER: Always present, always version 18
  • MPHD: Always present, flags evolve across versions
  • MAIN: Always present, defines tile existence

Conditional Chunks

  • MWMO:
    • 1.12.1-3.3.5a: Present in ALL maps (empty for terrain maps)
    • 4.x+: Only in WMO-only maps (flag 0x0001)
  • MODF: Only in WMO-only maps with objects (flag 0x0001)

Version-Specific Chunks

  • MAID: 8.1.0+ (BfA) - FileDataID system
  • Light chunks (_lgt.wdt): 7.0+ (Legion)
  • Fog chunks (_fogs.wdt): 7.0+ (functional in 8.0+)
  • MANM: 8.3.0 PTR only (removed before release)

Evolution Across Versions

Classic (1.x) - Foundation

  • Format: Basic structure with MVER, MPHD, MAIN chunks
  • Content Split: ~60% WMO-only, ~40% terrain maps
  • Flags: Minimal usage (only 0x0001 for WMO-only)
  • MODF Values: UniqueID=0xFFFFFFFF, Scale=0

Burning Crusade (2.x) - Expansion

  • No format changes - Complete compatibility
  • Content: Added Outland with massive terrain maps
  • Known Issues: DireMaul rotation bug (degrees vs radians)

Wrath of the Lich King (3.x) - Feature Enhancement

  • Major Flag Adoption (while maintaining format compatibility):
    • 0x0002 (MCCV): 60% of maps
    • 0x0004 (Big Alpha): 60% of maps
    • 0x0008 (Sorted Doodads): 35% of maps
  • Content Evolution: 70% terrain maps (shift from WMO-heavy design)
  • Advanced Terrain: Death Knight zone, Icecrown Citadel

Cataclysm (4.x) - BREAKING CHANGE

  • MAJOR FORMAT CHANGE: Terrain maps NO LONGER have MWMO chunks (only WMO-only maps have them)
  • Universal Flag: 0x0040 in 100% of maps (purpose unknown, possibly related to new rendering)
  • Near-Universal Features:
    • 0x0008 (Sorted): 95% of maps
    • Improved terrain blending and sorting
  • Phasing Technology: 1-2 tile maps for seamless world updates
  • Content: 80% terrain maps
  • Flag Pattern Changes:
    • Maps without HasTerrain flag (0x0001) no longer have MWMO/MODF chunks
    • Clear distinction between WMO-only and terrain-based maps

Mists of Pandaria (5.x) - Refinement

  • No structural changes - Stable format
  • Flag 0x0080 Active: Height texturing in 20% of maps
  • New Content Systems:
    • Scenarios: Instanced story content (16-25 tiles)
    • Pet Battles: Dedicated battle arenas (9-16 tiles)
  • Optimization: All MWMO chunks under 256 bytes

Legion (7.x)

  • Added _lgt.wdt files with MPL2, MSLT, MTEX, MLTA chunks
  • Enhanced fog system with MVFX/VFOG/VFEX chunks
  • Support for point and spot lights with texture projection
  • _fogs.wdt files added (initially empty)

Battle for Azeroth (8.x)

  • 8.0.1: Added _mpv.wdt files for particulate volume effects
  • 8.1.0: Major change - introduction of MAID chunk
  • Transition from filename-based to FileDataID system
  • Support for _occ,_lgt, _fogs,_mpv, _tex,_pd4 files
  • _fogs.wdt files became functional with fog data
  • Temporary MANM chunk during 8.3.0 PTR
  • Deprecated MPHD flag 0x0010 (AdtHasLightingVertices)

Shadowlands (9.x)

  • Enhanced lighting system with MPL3 replacing MPL2
  • Additional light properties for shadows and rendering
  • Extended MAID structure variations
  • Further refinements to fog and volumetric systems

FileDataID System

Starting with patch 8.1.0, WoW transitioned from filename-based file references to FileDataID system:

Pre-8.1.0 System

world/maps/azeroth/azeroth_29_29.adt
world/maps/azeroth/azeroth_29_29_obj0.adt
world/maps/azeroth/azeroth_29_29_tex0.adt

Post-8.1.0 System

  • Files are referenced by numeric FileDataIDs
  • MAID chunk contains all FileDataIDs for map files
  • Allows for more efficient patching and content delivery

Example FileDataID Mapping

#![allow(unused)]
fn main() {
// Example from actual game data
const AZEROTH_29_29_ROOT: u32 = 777332;
const AZEROTH_29_29_OBJ0: u32 = 777333;
const AZEROTH_29_29_OBJ1: u32 = 777334;
const AZEROTH_29_29_TEX0: u32 = 777335;
const AZEROTH_29_29_LOD: u32 = 1287004;
}

Additional WDT Files

Later WoW versions use multiple WDT files per map, each serving specific purposes:

_lgt.wdt - Lighting (Legion 7.0+)

Contains global lighting information and light sources.

  • Chunks: MPL2/MPL3 (point lights), MSLT (spotlights), MTEX (textures), MLTA (animations)
  • Purpose: Enhanced lighting system with dynamic lights

_occ.wdt - Occlusion

Low-resolution occlusion data for visibility culling.

  • Chunks: MAOI (occlusion index), MAOH (occlusion heightmap)
  • Purpose: Optimize rendering by culling non-visible areas

_fogs.wdt - Fog Effects (Legion 7.0+, functional in BfA 8.0+)

Volumetric fog definitions and atmospheric effects.

  • Chunks: MVFX (fog effects), VFOG (fog volumes), VFEX (extended fog data)
  • Purpose: Atmospheric and weather effects

_mpv.wdt - Particulate Volume (BfA 8.0.1+)

Particulate effects and volume data.

  • Purpose: Volumetric particle effects like dust, smoke, etc.

_tex.wdt - Textures

Texture-related data and references.

  • Chunks: MTXF (texture flags), MTXP (texture parameters)
  • Purpose: Additional texture properties and parameters

_pd4.wdt

Purpose not fully documented.

  • Note: Related to physics or collision data (speculation)

Implementation Notes from TrinityCore

Based on TrinityCore’s 3.3.5a implementation:

  1. Chunk Magic Reversal: TrinityCore stores chunk magics in reversed byte order:

    • MPHD is stored as { 'D', 'H', 'P', 'M' }
    • MAIN is stored as { 'N', 'I', 'A', 'M' }
    • MVER is stored as { 'R', 'E', 'V', 'M' }

  2. Chunk Offset Calculation: Chunks are located at:

    • MVER: Start of file
    • MPHD: version_offset + version->size + 8
    • MAIN: mphd_offset + mphd->size + 8

  3. ADT File Existence: Check adt_list[y][x].exist & 0x1

  4. Scale Field: The MODF structure includes a 16-bit scale field (1024 = 1.0)

  5. Simple Flag Usage: For 3.3.5a, only the first flag field in MPHD is used

Implementation Status - ✅ Implemented

WDT parsing is implemented in the wow-wdt crate with support for all WoW versions from Classic through later expansions.

Key Features:

  • Parse WDT files using WdtReader::from_reader()
  • Support for all chunk types (MVER, MPHD, MAIN, MAID, MWMO, MODF)
  • Version-aware parsing with validation
  • Coordinate system conversion utilities
  • 100+ real WDT files tested across all versions

References

  1. wowdev.wiki - Primary source for WoW file format documentation

    • Contains chunk definitions and flag values

  2. libwarcraft - C# implementation by WowDevTools

    • Fully compliant WDT read/write support

  3. StormLib - C++ MPQ library by Ladislav Zezula

    • Reference implementation for reading WoW data files

  4. AzerothCore - Open-source WoW server

    • Map extractor implementation and MWMO handling

  5. Noggit - Open-source WoW map editor

    • Practical implementation of WDT generation

  6. WoW Modding Community - Various tools and documentation

    • FileDataID conversion tools and MAID chunk handling

This documentation represents the collective knowledge of the WoW modding community and is based on reverse engineering efforts. Blizzard Entertainment has not officially documented these formats.