1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
(listfile)
(signature)
(attributes)
war3map.w3e
war3map.w3i
war3map.wtg
war3map.wct
war3map.wts
war3map.j
war3map.shd
war3mapMap.blp
war3mapMap.b00
war3mapMap.tga
war3mapPreview.tga
war3map.mmp
war3mapPath.tga
war3map.wpm
war3map.doo
war3mapUnits.doo
war3map.w3r
war3map.w3c
war3map.w3s
war3map.w3u
war3map.w3t
war3map.w3a
war3map.w3b
war3map.w3d
war3map.w3q
war3mapMisc.txt
war3mapSkin.txt
war3mapExtra.txt
war3map.imp
war3mapImported\*.* 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Header:
- char[4]: file ID = "W3E!"
- int: w3e format version [0B 00 00 00]h = version 11
- char: main tileset [TS]
  Tileset	Meaning
  A Ashenvale
  B Barrens
  C Felwood
  D Dungeon
  F Lordaeron Fall
  G Underground
  L Lordaeron Summer
  N Northrend
  Q Village Fall
  V Village
  W Lordaeron Winter
  X Dalaran
  Y Cityscape
  Z Sunken Ruins
  I Icecrown
  J Dalaran Ruins
  O Outland
  K Black Citadel

- int: custom tilesets flag (1 = using custom, 0 = not using custom tilesets)
- int: number a of ground tilesets used (Little Endian) (note: should not be greater than 16 because of tilesets indexing in tilepoints definition)
- char[4][a]: ground tilesets IDs (tilesets table)
  Example: "Ldrt" stands for "Lordaeron Summer Dirt"
  (refer to the files "TerrainArt\Terrain.slk" located in your war3.mpq for more details)
- int: number b of cliff tilesets used (Little Endian) 
  (note: should not be greater than 16 because of tilesets indexing in tilepoints definition)
- char[4][b]: cliff tilesets IDs (cliff tilesets table)
  Example: "CLdi" stands for Lordaeron Cliff Dirt
  (refer to the files "TerrainArt\CliffTypes.slk" located in your war3.mpq for more details)
  the cliff tile list is actually ignored, the World Editor will simply add the cliff tiles for each tile in the ground tile list, if a cliff version of this ground tile exists
- int: width of the map + 1 = Mx
- int: height of the map + 1 = My
  Example: if your map is 160x128, Mx=A1h and My=81h
- float: center offeset of the map X
- float: center offeset of the map Y
  These 2 offsets are used in the scripts files, doodads and more.
  The orginal (0,0) coordinate is at the bottom left of the map (looking from the top) and it's easier to work with (0,0) in the middle of the map so usually, these offsets are :
  -1*(Mx-1)*128/2 and -1*(My-1)*128/2
  where:
  (Mx-1) and (My-1) are the width and the height of the map
  128 is supposed to be the size of tile on the map
  /2 because we don't want the length but the middle.
  -1* because we're "translating" the center of the map, not giving it's new coordinates

Data:
Each tilepoint is defined by a block of 7 bytes.
The number of blocks is equal to Mx*My.
- short: ground height
  C000h: minimum height (-16384)
  2000h: normal height (ground level 0)
  3FFFh: maximum height (+16383)
- short: water level + map edge boundary flag*(see notes)
- 4bit: flags*(see notes)
- 4bit: ground texture type (grass, dirt, rocks,...)
- 1byte: texture details 
  (of the tile of which the tilepoint is the bottom left corner) (rocks, holes, bones,...). It appears that only a part of this byte is used for details. It needs more investigations
- 4bit: cliff texture type
- 4bit: layer height

1
2
3
4
5
6
7
8
9
Flags values (shown as big endian):
0x4000 --> boundary flag 1 (shadow generated by the world editor on the edge of the map)
0x0010 --> ramp flag (used to set a ramp between two layers)
0x0020 --> blight flag (ground will look like Undead's ground)
0x0040 --> water flag (enable water)
0x0080 --> boundary flag 2 (used on "camera bounds" area. Usually set by the World Editor "boundary" tool.)

Water level:
Water level is stored just like ground height. The highest bit (bit 15) is used for the boundary flag 1.

1
51 21 00 62 56 84 13

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
51 21 --(little endian)--> 0x2151 --(hex-->dec)--> height = 8529
00 62 --(little endian)--> 0x6200
(extract boundary flag)--> (0x6200 & 0xC000) = 0x4000 boundary flag set
(extract water data)--> (0x6200 & 0x3FFF) = 0x2200 --(hex-->dec)--> water level = 8704
56 --> 5 sets both water flag and ramp flag, 6 means tilepoint is using ground type #6 in the tilesets table
84 --> means tilepoint is using detail texture #132 (=0x084)
13 --> 1 means cliff type #1 (cliff tilesets table), 3 means tilepoint on layer "3"
The tilepoint "final height" you see on the WE is given by:
(ground_height - 0x2000 + (layer - 2)*0x0200)/4
where "0x2000" is the "ground zero" level, 2 the "layer zero" level and "0x0200" the layer height
= (0x2151 - 0x2000 + 1*0x0200)/4
= (8529 - 8192 + 512)/4
= 212,25

The tilepoint "water level" you see on the WE is given by:
(water_level - 0x2000)/4 - 89.6
where "0x2000" is the "ground zero" level, -89.6 is the water zero level (given by the water.slk file height = -0,7 --> water_zero_level = -0,7*128):
= 8704/4 - 89,6
= 38,4

1
00 00 02 00 00 00 00 00 00 00 00 00 XX XX YY YY 20 28

1
2
3
4
5
6
7
8
9
10
One pixel is defined by 4 bytes:
BB GG RR AA
Where:
BB is the blue value (0 or 255)
GG is the green value (0 or 255)
RR is the red value (0 or 255)
AA is the alpha chanel value (set to 0)
There are 4*4 pixels for 1 tileset.
The TGA width is map_width*4.
The TGA height is map_height*4.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Header:
char[4]: file ID = 'MP3W'
int: file version = 0
int: path map width (=map_width*4)
int: path map height (=map_height*4)

Data:
Each byte of the data part is a part of a tileset exactly like for the TGA.
Data size: (map_height*4)*(map_with*4) bytes
Flags table:
0x01: 0 (unused)
0x02: 1=no walk, 0=walk ok
0x04: 1=no fly, 0=fly ok
0x08: 1=no build, 0=build ok
0x10: 0 (unused)
0x20: 1=blight, 0=normal
0x40: 1=no water, 0=water
0x80: 1=unknown, 0=normal

1
2
3
4
char[4]: file ID = "W3do"
int: file version = 8
int: subversion? ([0B 00 00 00]h)
int: number of trees defined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
char[4]: Tree ID
int: Variation (little endian)
float: Tree X coordinate on the map
float: Tree Y coordinate on the map
float: Tree Z coordinate on the map
float: Tree angle (radian angle value)(degree = radian*180/pi)
float: Tree X scale
float: Tree Y scale
float: Tree Z scale
byte: Tree flags*
byte: Tree life (integer stored in %, 100% is 0x64, 170% is 0xAA for example)
int: Random item table pointer
  if -1 -> no item table
  if >= 0 -> items from the item table with this number (defined in the w3i) are dropped on death
int: number "n" of item sets dropped on death (this can only be greater than 0 if the item table pointer was -1)
then there is n times a item set structure
int: Tree ID number in the World Editor (little endian) (each tree has a different one)

1
2
3
0= invisible and non-solid tree
1= visible but non-solid tree
2= normal tree (visible and solid)

1
2
3
4
5
6
7
tt tt tt tt vv vv vv vv 
xx xx xx xx yy yy yy yy 
zz zz zz zz aa aa aa aa 
xs xs xs xs ys ys ys ys 
zs zs zs zs ff ll 
bb bb bb bb cc cc cc cc 
dd dd dd dd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
tt: type
vv: variation
xx: x coordinate
yy: y coordinate
zz: z coordinates
aa: rotation angle
xs: x scale
ys: y scale
zs: z scale
ff: flags
ll: life
bb: item table pointer
cc: number of items dropped on death (0)
dd: doodad number in the editor

1
2
3
4
5
6
7
int: special doodad format version set to '0'
int: number "s" of "special" doodads ("special" like cliffs,...)
Then "s" times a special doodad structure (16 bytes each):
char[4]: doodad ID
int: Z? (0)
int: X? (w3e coordinates)
int: Y? (w3e coordinates)

1
2
3
4
5
int: number "n" of items in the item set
then we have n times then following two values (for each item set)
char[4]: item id (as in ItemData.slk)
this can also be a random item id (see bottom of war3mapUnits.doo definition)
int: percentual chance of choice

1
2
3
4
char[4]: file ID = "W3do"
int: file version = 8
int: subversion? (often set to [0B 00 00 00]h)
int: number of units and items defined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
char[4]: type ID (iDNR = random item, uDNR = random unit) (thx PitzerMike)
int: variation
float: coordinate X
float: coordinate Y
float: coordinate Z
float: rotation angle
float: scale X
float: scale Y
float: scale Z
char[4]: type ID (exists in new version)
byte: flags*
int: player number (owner) (player1 = 0, 16=neutral passive)
byte: unknown (0)
byte: unknown (0)
int: hit points (-1 = use default)
int: mana points (-1 = use default, 0 = unit doesn't have mana)
int: map item table pointer (for dropped items on death)
if -1 => no item table used
if >= 0 => the item table with this number will be dropped on death
int: number "s" of dropped item sets (can only be greater 0 if the item table pointer was -1)
then we have s times a dropped item sets structures (see below)
int: gold amount (default = 12500)
float: target acquisition (-1 = normal, -2 = camp)
int: hero level (set to1 for non hero units and items)
int: strength of the hero (0 = use default)
int: agility of the hero (0 = use default)
int: intelligence of the hero (0 = use default)
int: number "n" of items in the inventory
then there is n times a inventory item structure (see below)
int: number "n" of modified abilities for this unit
then there is n times a ability modification structure (see below)
int: random unit/item flag "r" (for uDNR units and iDNR items)
0 = Any neutral passive building/item, in this case we have
  byte[3]: level of the random unit/item,-1 = any (this is actually interpreted as a 24-bit number)
  byte: item class of the random item, 0 = any, 1 = permanent ... (this is 0 for units)
  r is also 0 for non random units/items so we have these 4 bytes anyway (even if the id wasn't uDNR or iDNR)
1 = random unit from random group (defined in the w3i), in this case we have
  int: unit group number (which group from the global table)
  int: position number (which column of this group)
  the column should of course have the item flag set (in the w3i) if this is a random item
2 = random unit from custom table, in this case we have
  int: number "n" of different available units
  then we have n times a random unit structure

int: custom color (-1 = none, 0 = red, 1=blue,...)
int: Waygate: active destination number (-1 = deactivated, else it's the creation number of the target rect as in war3map.w3r)
int: creation number

1
2
3
0= invisible and non-solid tree
1= visible but non-solid tree
2= normal tree (visible and solid)

1
2
3
4
5
int: number "d" of dropable items
"d" times dropable items structures:
char[4]: item ID ([00 00 00 00]h = none)
this can also be a random item id (see below)
int: % chance to be dropped

1
2
3
int: inventory slot (this is the actual slot - 1, so 1 => 0)
char[4]: item id (as in ItemData.slk) 0x00000000 = none
this can also be a random item id (see below)

1
2
3
char[4]: ability id (as in AbilityData.slk)
int: active for autocast abilities, 0 = no, 1 = active
int: level for hero abilities

1
2
3
char[4]: unit id (as in UnitUI.slk)
this can also be a random unit id (see below)
int: percentual chance of choice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
int: file format version = 25
int: number of saves (map version)
int: editor version (little endian)
String: map name
String: map author
String: map description
String: players recommended
float[8]: "Camera Bounds" as defined in the JASS file
int[4]: camera bounds complements* (see note 1) (ints A, B, C and D)
int: map playable area width E* (see note 1)
int: map playable area height F* (see note 1)
  *note 1:
  map width = A + E + B
  map height = C + F + D
int: flags
  0x0001: 1=hide minimap in preview screens
  0x0002: 1=modify ally priorities
  0x0004: 1=melee map
  0x0008: 1=playable map size was large and has never been reduced to medium (?)
  0x0010: 1=masked area are partially visible
  0x0020: 1=fixed player setting for custom forces
  0x0040: 1=use custom forces
  0x0080: 1=use custom techtree
  0x0100: 1=use custom abilities
  0x0200: 1=use custom upgrades
  0x0400: 1=map properties menu opened at least once since map creation (?)
  0x0800: 1=show water waves on cliff shores
  0x1000: 1=show water waves on rolling shores
  0x2000: 1=unknown
  0x4000: 1=unknown
  0x8000: 1=unknown
char: map main ground type
  Example: 'A'= Ashenvale, 'X' = City Dalaran
int: Loading screen background number which is its index in the preset list (-1 = none or custom imported file)
String: path of custom loading screen model (empty string if none or preset)
String: Map loading screen text
String: Map loading screen title
String: Map loading screen subtitle
int: used game data set (index in the preset list, 0 = standard)
String: Prologue screen path (usually empty)
String: Prologue screen text (usually empty)
String: Prologue screen title (usually empty)
String: Prologue screen subtitle (usually empty)
int: uses terrain fog (0 = not used, greater 0 = index of terrain fog style dropdown box)
float: fog start z height
float: fog end z height
float: fog density
byte: fog red value
byte: fog green value
byte: fog blue value
byte: fog alpha value
int: global weather id (0 = none, else it's set to the 4-letter-id of the desired weather found in TerrainArt\Weather.slk)
String: custom sound environment (set to the desired sound lable)
char: tileset id of the used custom light environment
byte: custom water tinting red value
byte: custom water tinting green value
byte: custom water tinting blue value
byte: custom water tinting alpha value
int: max number "MAXPL" of players
array of structures: then, there is MAXPL times a player data like described below.
int: max number "MAXFC" of forces
array of structures: then, there is MAXFC times a force data like described below.
int: number "UCOUNT" of upgrade availability changes
array of structures: then, there is UCOUNT times a upgrade availability change like described below.
int: number "TCOUNT" of tech availability changes (units, items, abilities)
array of structures: then, there is TCOUNT times a tech availability change like described below
int: number "UTCOUNT" of random unit tables
array of structures: then, there is UTCOUNT times a unit table like described below
int: number "ITCOUNT" of random item tables
array of structures: then, there is ITCOUNT times a item table like described below

1
2
3
4
5
6
7
8
9
10
11
int: internal player number
int: player type
1=Human, 2=Computer, 3=Neutral, 4=Rescuable
int: player race
1=Human, 2=Orc, 3=Undead, 4=Night Elf
int: 00000001 = fixed start position
String: Player name
float: Starting coordinate X
float: Starting coordinate Y
int: ally low priorities flags (bit "x"=1 --> set for player "x")
int: ally high priorities flags (bit "x"=1 --> set for player "x")

1
2
3
4
5
6
7
8
int: Foces Flags
0x00000001: allied (force 1)
0x00000002: allied victory
0x00000004: share vision
0x00000010: share unit control
0x00000020: share advanced unit control
int: player masks (bit "x"=1 --> player "x" is in this force)
String: Force name

1
2
3
4
int: Player Flags (bit "x"=1 if this change applies for player "x")
char[4]: upgrade id (as in UpgradeData.slk)
int: Level of the upgrade for which the availability is changed (this is actually the level - 1, so 1 => 0)
int Availability (0 = unavailable, 1 = available, 2 = researched)

1
2
3
int: Player Flags (bit "x"=1 if this change applies for player "x")
char[4]: tech id (this can be an item, unit or ability)
there's no need for an availability value, if a tech-id is in this list, it means that it's not available

1
2
3
4
5
6
7
8
9
10
11
12
13
int: Number "n" of random groups
then we have n times the following data (for each group)
int: Group number
string: Group name
int: Number "m" of positions
positions are the table columns where you can enter the unit/item ids, all units in the same line have the same chance, but belong to different "sets" of the random group, called positions here
int[m]: for each positon is specified if it's a unit table (=0), a building table (=1) or an item table (=2)
int: Number "i" of units/items, this is the number of lines in the table, each position can have that many or fewer entries
now there's "i" times the following structure (for each line)
int: Chance of the unit/item (percentage)
char[m * 4]: for each position are the unit/item id's for this line specified
this can also be a random unit/item ids (see bottom of war3mapUnits.doo definition)
a unit/item id of 0x00000000 indicates that no unit/item is created

1
2
3
4
5
6
7
8
9
10
11
int: Number "n" of random item tables
then we have n times the following data (for each item table)
int: Table number
string: Table name
int: Number "m" of item sets on the current item table
then we have m times the following data (for each item set)
int: Number "i" of items on the current item set
then we have i times the following two values (for each item)
int: Percentual chance
char[4]: Item id (as in ItemData.slk)
this can also be a random item id (see bottom of war3mapUnits.doo definition)

1
2
3
4
STRING 0
{
Blah blah blah...
}

1
2
3
4
5
6
7
8
9
10
11
char[4]: file ID ("BLP1")
int: 0 for JPG-BLP, 1 for Paletted
int: 0x00000008 = has alpha, 0x00000000 = no alpha
int: image width
int: image height
int: flag for alpha channel and team colors (usually 3, 4 or 5), 
  3 and 4 means color and alpha information for paletted files, 
  5 means only color information, if >=5 on 'unit' textures, it won't show the team color.
int: always 0x00000001, if 0x00000000 the model that uses this texture will be messy.
int[16]: mipmap offset (offset from the begining of the file)
int[16]: mipmap size (size of mipmaps)

1
2
3
4
int: jpg header size (header size) "h" (usually 0x00000270)
byte[h]: header
followed by 0 bytes until the begining of the jpeg data, we can safely erase these 0 bytes if we fix the mipmap offset specified above
byte[16, mipmap size]: starting from each of the 16 mipmap offset addresses we read 'mipmap size' bytes raw jpeg data till the end of the file, having the header and the mipmap data we can process the picture like ordinary JPG files

1
2
3
4
byte[4, 255]: the BGRA palette defining 256 colors by their BGRA values, each 1 byte
byte[width x height]: the ColorIndex of each pixel from top left to bottom right, ColorIndex refers to the above defined color palette
byte[width x height]: the AlphaIndex of each pixel on a standard greyscale palette for the alpha channel, where 0 is fully transparent and 255 is opaque,
if the picturetype flag is set to 5, the image doesn't have an alpha channel, so this section will be omitted

1
2
int: unknown (usually 0, maybe the file format)
int: number of datasets

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int: icon type
  Icons Types:
    00: gold mine
    01: house
    02: player start (cross)
int: X coordinate of the icon on the map
int: Y coordinate of the icon on the map
Map Coordinates:
 top left: 10h, 10h
 center: 80h, 80h
 bottom right: F0h, F0h
byte[4]: player icon color
Player Colors (BB GG RR AA = blue, green, red, alpha channel):
 03 03 FF FF : red
 FF 42 00 FF : blue
 B9 E6 1C FF : cyan
 81 00 54 FF : purple
 00 FC FF FF : yellow
 0E 8A FE FF : orange
 00 C0 20 FF : green
 B0 5B E5 FF : pink
 97 96 95 FF : light gray
 F1 BF 7E FF : light blue
 46 62 10 FF : aqua
 04 2A 49 FF : brow
 FF FF FF FF : none

1
2
3
int: W3U Version = 1
x bytes: Original Units table*
y bytes: User-created units table*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
*Table definition:
int: number n of units on this table.
If 0 on original table, then skip default unit table. This is the number of following units. Even if we don't have any changes on original table, this value must be there.
n times a unit definition structure*.

*Unit definition structure:
char[4]: original unit ID (get the IDs from "Units\UnitData.slk" of war3.mpq)
char[4]: new unit ID. If it is on original table, this is 0, since it isn't used.
int: number m of modifications for this unit
m times a modification structure*

*Modification structure:
char[4] modification ID code (get the IDs from "Units\UnitMetaData.slk" of war3.mpq)
int: variable type* t (0=int, 1=real, 2=unreal, 3=String,...)
t type: value (length depends on the type t specified before)
int: end of unit definition (usually 0)

*Variable types:
0=int
1=real
2=unreal
3=string
4=bool
5=char
6=unitList
7=itemList
8=regenType
9=attackType
10=weaponType
11=targetType
12=moveType
13=defenseType
14=pathingTexture
15=upgradeList
16=stringList
17=abilityList
18=heroAbilityList
19=missileArt
20=attributeType
21=attackBits

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int: File Version = (usually 1)
x bytes: Original objects table*
y bytes: Custom objects table*
Data:
*Table definition:
int: number n of objects on this table, if 0 on the original table, then skip the default object table. This is the number of following units. Even if we don't have any changes on original table, this value must be there.
n times a object definition structure*.
*Object definition structure:
char[4]: original object ID (see table at the bottom where you can get the object IDs*)
char[4]: new object ID. (if it is on original table, this is 0, since it isn't used)
int: number m of modifications for this object
m times a modification structure*
*Modification structure:
char[4] modification ID (see the table at the bottom where you can get the mod IDs*)
int: variable type* t
[int: level/variation (this integer is only used by some object files depending on the object type, for example the units file doesn’t use this additional integer, but the ability file does, see the table at the bottom to see which object files use this int*) in the ability and upgrade file this is the level of the ability/upgrade, in the doodads file this is the variation, set to 0 if the object doesn't have more than one level/variation]
[int: data pointer (again this int is only used by those object files that also use the level/variation int, see table*) in reality this is only used in the ability file for values that are originally stored in one of the Data columns in AbilityData.slk, this int tells the game to which of those columns the value resolves (0 = A, 1 = B, 2 = C, 3 = D, 4 = F, 5 = G, 6 = H), for example if the change applies to the column DataA3 the level int will be set to 3 and the data pointer to 0]
int, float or string: value of the modification depending on the variable type specified by t
int: end of modification structure (this is either 0, or equal to the original object ID or equal to the new object ID of the current object, when reading files you can use this to check if the format is correct, when writing a file you should use the new object ID of the current object here)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int: file version (currently 1)
int: contains unit data file (1 = yes, 0 = no)
if yes, then here follows a complete w3u file (see w3u specifications above)
int: contains item data file (1 = yes, 0 = no)
if yes, then here follows a complete w3t file (see w3t specifications above)
int: contains destructable data file (1 = yes, 0 = no)
if yes, then here follows a complete w3b file (see w3b specifications above)
int: contains doodad data file (1 = yes, 0 = no)
if yes, then here follows a complete w3d file (see w3d specifications above)
int: contains ability data file (1 = yes, 0 = no)
if yes, then here follows a complete w3a file (see w3a specifications above)
int: contains buff data file (1 = yes, 0 = no)
if yes, then here follows a complete w3h file (see w3h specifications above)
int: contains upgrade data file (1 = yes, 0 = no)
if yes, then here follows a complete w3q file (see w3q specifications above)

1
2
3
4
5
6
7
8
9
char[4]: file ID (WTG!)
int: wtg file format version = 4
int: number "a" of triggers categories
"a" times a category definition structure*
int: number "b" ???
int: number "c" of variables
"c" times a variable definition structure**
int: number "d" of triggers
"d" times a trigger definition structure***

1
2
int: category index
String: category name

1
2
3
4
5
6
String: variable name
String: variable type
int: number "e" ???
int: array status: 0=not an array, 1=array
int: initialisation status: 0=not initialized, 1=initialized
String: initial value (string)

1
2
3
4
5
6
7
8
9
String: trigger name
String: trigger description
int: enable state: 0=disabled, 1=enabled
int: custom text trigger state: 0=not a custom text trigger, 1=custom text trigger (use data in the WCT)
int: initial state: 0=initially on, 1=not initially on
int: ???
int: index of the category the trigger belongs to
int: number "i" of event-condition-action (ECA) function
"i" times an ECA function definition structure*(4) (if it's a custom text trigger i should be 0 so we don't have this section)

1
2
3
4
int: function type: 0=event, 1=condition, 2=action
String: function name
int: enable state: 0=function disabled, 1=function enabled
"x" times a parameter structure*(5). x depends of the function and is hardcoded.

1
2
3
4
int: 0=preset, 1=variable, 2=function
String: parameter value
int: ???
int: ???

1
2
3
4
5
6
7
8
9
char[4]: file ID (WTG!)
int: wtg file format version = 7
int: number "a" of triggers categories
"a" times a category definition structure*
int: number "b" ???
int: number "c" of variables
"c" times a variable definition structure**
int: number "d" of triggers
"d" times a trigger definition structure***

1
2
3
int: category index
String: category name
int: Category type: 0=normal, 1=comment

1
2
3
4
5
6
7
String: variable name
String: variable type
int: number "e" ???
int: array status: 0=not an array, 1=array
int: array size
int: initialisation status: 0=not initialized, 1=initialized
String: initial value (string)

1
2
3
4
5
6
7
8
9
10
String: trigger name
String: trigger description
int: trigger type: 0=normal, 1=comment
int: enable state: 0=disabled, 1=enabled
int: custom text trigger state: 0=not a custom text trigger, 1=custom text trigger (use data in the WCT)
int: initial state: 0=initially on, 1=not initially on
int: run on map initialization: 0=no, 1=yes
int: index of the category the trigger belongs to
int: number "i" of event-condition-action (ECA) function
"i" times an ECA function definition structure*(4) (if it's a custom text trigger it should be 0 so we don't have this section)

1
2
3
4
5
6
7
int: function type: 0=event, 1=condition, 2=action
String: function name
int: enable state: 0=function disabled, 1=function enabled
"x" times a parameter structure*(5). x depends of the function and is hardcoded.
int: ???
int: number "i" of event-condition-action (ECA) function
"i" times an ECA function definition structure*(4)(if this trigger doesn't have multiple actions it should be set to 0 so we don't have this section)

1
2
3
4
5
6
7
8
9
int: type which can be 0=preset, 1=variable, 2=function, 3=string
String: parameter value
int: begin function (if it is function it should be set to 1 otherwise to 0)
if begin function is set to 1:
int: type: 3
String: the same as parameter value
int: begin function: 1
"x" times a parameters structure*(5). x depends on the function and is hardcoded.
int: end function (always set to 0)

1
2
int: file version = 0
int: number "n" of camera definition structures

1
2
3
4
5
6
7
8
9
10
11
float: Target X
float: Target Y
float: Z Offset
float: Rotation (angle in degree)
float: Angle Of Attack (AoA) (angle in degree)
float: Distance
float: Roll
float: Field of View (FoV) (angle in degree)
float: Far Clipping (FarZ)
float: ??? (usually set to 100)
String: Cinematic name

1
2
int: version = 5
int: number "n" of region definition structures*

1
"n" times a region definition structure

1
2
3
4
5
6
7
8
9
10
11
float: left (jass coordinates)
float: right (jass coordinates)
float: bottom (jass coordinates)
float: top (jass coordinates)
String: region name
int: Region index number (creation number)
char[4]: weather effect ID (ex.: "RLlr" for "Rain Lordaeron Light Rain")
If all the chars are set to 0, then weather effect is disabled.
String: ambient sound (a sound ID name defined in the w3s file like "gg_snd_HumanGlueScreenLoop1")
bytes[3]: region color (used by the World Editor) (BB GG RR)
byte: end of the structure

1
2
int: file format version = 1
int: number "n" of sounds defined

1
"n" times a sound definition structure*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
String: sound ID name (like "gg_snd_HumanGlueScreenLoop1")
String: sound file (like "Sound\Ambient\HumanGlueScreenLoop1.wav")
String: EAX effects (like "DefaultEAXON")
DefaultEAXON=Default
CombatSoundsEAX=combat
KotoDrumsEAX=drums
SpellsEAX=spells
MissilesEAX=missiles
HeroAcksEAX=hero speech
DoodadsEAX=doodads
int: sound flags
0x00000001=looping
0x00000002=3D sound
0x00000004=stop when out of range
0x00000008=music
0x00000010=
int: fade in rate
int: fade out rate
int: volume (-1=use default value)
float: pitch
float: ???
int: ??? (-1 or 8)
int: channel:
0=General
1=Unit Selection
2=Unit Acknowledgement
3=Unit Movement
4=Unit Ready
5=Combat
6=Error
7=Music
8=User Interface
9=Looping Movement
10=Looping Ambient
11=Animations
12=Constructions
13=Birth
14=Fire
float: min. distance
float: max. distance
float: distance cutoff
float: ???
float: ???
int: ??? (-1 or 127)
float: ???
float: ???
float: ???

1
2
3
int: file version (0)
int: number "n" of triggers
"n" times a custom text trigger structure*

1
2
int: size "s" of the text (including the null terminating char)
String: custom text trigger string (contains "s chars including the null terminating char)

1
2
3
4
5
int: file version: 1
String: custom script code comment
1 time a custom text trigger structure*
int: number "n" of triggers
"n" times a custom text trigger structure*

1
2
int: size "s" of the text (including the null terminating char)
String: custom text trigger string (contains "s chars including the null terminating char)

1
2
int: file format version
int: number "n" of imported files

1
2
1byte: tells if the path is complete or needs "war3mapImported\" (5 or 8= standard path, 10 or 13: custom path) (thx PitzerMike)
String["n"]: the path inside the w3m of each imported file (like "war3mapImported\mysound.wav")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
int: wai file format version: 2
string: AI name
int: race: 0=Custom, 1=Human, 2=Orc, 3=Undead, 4=Night Elf
int: options
Unless otherwise noted all of the options are contained in HiWord of options integer.
Check for the presence of options by using a mask with following values:

SetPlayerName: 0x2000
Melee: 0x0001
DefendUsers: 0x8000
RandomPaths: 0x4000
TargetHeroes: 0x0002
RepairStructures: 0x0004
HeroesFlee: 0x0008
UnitsFlee: 0x0010
GroupsFlee: 0x0020
HaveNoMercy: 0x0040
IgnoreInjured: 0x0080
RemoveInjuries: 0x1000
TakeItems: 0x0100
BuyItems: 0x0001 LoWord
SlowHarvesting: 0x0200
AllowHomeChanges: 0x0400
SmartAltillery: 0x0800

int: number of following workers and buildings. If there are less than 4 workers and buildings specified, WorldEdit will choose default values. Should be: 4.
char[4]: gold worker
char[4]: wood worker
char[4]: base building
char[4]: mine building (If none, use the same identifer as base building)

int: number "a" of conditions
int: ???: 7
"a" times a conditions definition structure*
char[4]: First Hero Used (if none set these values to null otherwise set it to Unit ID)
char[4]: Second Hero Used (if none set these values to null otherwise set it to Unit ID)
char[4]: Third Hero Used (if none set these values to null otherwise set it to Unit ID)
int: Training Order % Chance(1.FirstHero,2.SecondHero,3.ThirdHero)
int: Training Order % Chance(1.FirstHero,2.ThirdHero,3.SecondHero)
int: Training Order % Chance(1.SecondHero,2.FirstHero,3.ThirdHero)
int: Training Order % Chance(1.SecondHero,2.ThirdHero,3.FirstHero)
int: Training Order % Chance(1.ThirdHero,2.FirstHero,3.SecondHero)
int: Training Order % Chance(1.ThirdHero,2.SecondHero,3.FirstHero)

Skill Selection Order:
char[4*10]: Ten Skill IDs for First Hero(as first hero)
char[4*10]: Ten Skill IDs for First Hero(as second hero)
char[4*10]: Ten Skill IDs for First Hero(as third hero)
char[4*10]: Ten Skill IDs for Second Hero(as first hero)
char[4*10]: Ten Skill IDs for Second Hero(as second hero)
char[4*10]: Ten Skill IDs for Second Hero(as third hero)
char[4*10]: Ten Skill IDs for Third Hero(as first hero)
char[4*10]: Ten Skill IDs for Third Hero(as second hero)
char[4*10]: Ten Skill IDs for Third Hero(as third hero)
int: number "c" of Build Priorities
"c" times build priorities structure***
int: number "d" of Harvest Priorities
"d" times harvest priorities structure *(4)
int: number "e" of Target Priorities
"e" times target priorities structure *(5)
int: repeats waves
int: minimum forces: attack group index(for First Hero Only set this value to char[4]:HAIA)
int: initial delay
int: number "f" of Attack Groups
"f" times attack groups structure *(6)
int: number "g" of Attack Waves
"g" times attack waves structure *(8)
int: ???: 1
int: game options
Unless otherwise noted all of the options are contained in HiWord of options integer.
Check for the presence of options by using a mask with following values:

Disable Fog Of War: 0x0001
Disable Victory/Defeat Conditions: 0x0002

int: regular game speed
string: path to map file
int: number "h" of Players (0-2)
"h" times players structure *(9)
int: ???

1
2
3
4
5
6
7
8
int: condition index
String: condition name
int: number "b": 0=none(empty condition), 1=condition
if number "b" = 1
String: operator function name
int: begin function: 1
"x" times a Parameters Structure**. x depends on the function and is hardcoded.
int: end function: 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int: type: 0=preset, 1=operator function, 2=function, 3=string 
String: parameter value (if it is function and this value is empty, begin function means '(' and end function means ')' )
int: begin function (if it is function or operator function it should be set to 1 otherwise to 0)
if it is function and parameter value is not empty:
int: type: 3
String: the same as parameter value
int: begin function: 1
"x" times a Parameters Structure**. x depends on the function and is hardcoded.
int: end function: 0
if it is operator function:
int: begin function: 1
"x" times a Parameters Structure**. x depends on the function and is hardcoded.
int: end function
int: end function: 0

1
2
3
4
5
6
int: priorities type: 0
int: type: 0=unit, 1=upgrade, 2=expansion town
char[4]: Unit/Upgrade ID(if it is expansion town this value should be set to: XEIA)
int: town: 0=main, 1-9=Expansion #1-9, 0xFFFFFFFD-0xFFFFFFF5=current mine #1-9, 0xFFFFFFFF=any
int: condition index(if none set this value to 0xFFFFFFFF, if custom set this value to 0xFFFFFFFE)
1 time condition definition structure*(without condition index!)

1
2
3
4
5
6
int: priorities type: 1
int: harvest type: 0=gold, 1=lumber
int: town: 0=main, 1-9=Expansion #1-9, 0xFFFFFFFD-0xFFFFFFF5=current mine #1-9, 0xFFFFFFFF=any
int: workers: 0-90=fixed value #0-90, 0xFFFFFFFF=all, 0xFFFFFFFE=all not attacking
int: condition index(if none, set this value to 0xFFFFFFFF, if custom, set this value to 0xFFFFFFFE)
1 time condition definition structure*(without condition index!)

1
2
3
4
5
6
7
8
9
int: priorities type: 2
int: target: 0=common alliance target, 1=new expansion location, 2=enemy major assault,
3=enemy expansion, 4=enemy any town, 5=creep camp, 6=purchase goblin zeppelin
int: creep min strength(if target is other than 5 set this value to 0xFFFFFFFF)
if target = 5
int: creep max strength
int: allow flyers: 0=no, 1=yes
int: condition index(if none, set this value to 0xFFFFFFFF, if custom, set this value to 0xFFFFFFFE)
1 time condition definition structure*(without condition index!)

1
2
3
4
int: attack group index
string: attack group name
int: number "g" of Current Group
"g" times current group structure *(7)

1
2
3
4
5
char[4]: Unit ID (FirstHero: 1HIA, SecondHero: 2HIA, ThirdHero: 3HIA)
int: quantity value: 0-90=quantity #0-90, 0xFFFFFFFF=All
int: maximum quantity: 0-90=quantity #0-90, 0xFFFFFFFF=All(if quantity value is 0xFFFFFFFF, maximum quantity means all except #0-90)
int: condition index(if none, set this value to 0xFFFFFFFF, if custom, set this value to 0xFFFFFFFE)
1 time condition definition structure*(without condition index!)

1
2
int: attack group index
int: delay

1
2
3
4
5
6
7
8
9
int: player index
int: team number
int: race: 1=human, 2=orc, 8=undead, 4=night elf, 20=random
int: color: 0=red, 1=blue, 2=teal, 3=purple, 4=yellow, 5=orange, 6=green, 7=pink, 8=gray,
9=light blue, 10=dark green, 11=brown
int: handicap (0-100)
int: ai: 0=standard, 1=user, 4=custom, 12=current
int: ai difficulty: 0=easy, 1=normal, 2=insane
string: path to custom ai script

1
2
3
4
5
6
7
8
9
10
11
12
(listfile)
(signature)
(attributes)
war3campaign.w3u
war3campaign.w3t
war3campaign.w3a
war3campaign.w3b
war3campaign.w3d
war3campaign.w3q
war3campaign.w3f
war3campaign.imp
war3campaignImported\*.*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int: file format version (currently 1)
int: campaign version (how many times it has been saved)
int: saved with editor version
String: campaign name
String: campaign difficulty
String: author name
String: campaign description
int: variable difficulty levels flag + expansion flag
0=Fixed Diffculty, Only w3m maps
1=Variable Difficulty, Only w3m maps
2=Fixed Difficulty, Contains w3x maps
3=Variable Difficulty, Contains w3x maps
int: campaign background screen index (-1 = none or custom path)
String: path of custom background screen (empty if none or preset)
String: path of minimap picture (empty = none)
int: ambient sound index (-1 = imported file, 0 = none, greater 0 = preset index)
String: path of custom imported ambient sound mp3
int: uses terrain fog (0 = not used, greater 0 = index of terrain fog style dropdown box)
float: fog start z height
float: fog end z height
float: fog density
byte: fog red value
byte: fog green value
byte: fog blue value
byte: fog alpha value
int: cursor and ui race index (0 = human)
int: number "n" of maps in the campaign
"n" times a map title structure*
int: number "m" of maps in the flow chart (usually equal to "n")
"m" times a map order structure*

1
2
3
4
int: is map visible in the campaign screen from the beginning (1 = visible, 0 = invisible)
String: chapter title
String: map title
String: path of the map in the campaign archive

1
2
String: unknown (always empty, might also be a single character)
String: path of the map in the campaign archive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
char[28] signature: always "Warcraft III recorded game\0x1A\0"
uint header size: 0x40 for versions up to 1.06, 0x44 for later versions
uint compressed file size: including header
uint header version: 0x00 up to version 1.06, 0x01 for later versions
uint compressed size: size of the original decompressed file
uint "n": nr of compressed data blocks in the file
if (header version == 0) {
ushort unknown: always 0
ushort version number: the part behind the decimal point
} else {
char[4] version identifier: "WAR3" for classic, "W3XP" for expansion
uint version number: the part behind the decimal point
}
ushort build number: that is a unique id for each Warcraft III build
ushort flags: 0x0000 for single player, 0x8000 for multiplayer
uint length: in milli seconds for replays, 0x00000000 otherwise
uint checksum: CRC32 of the whole header until now, with this int set to 0
now there are "n" compressed blocks

1
2
3
int: reserved for version (currently nr of gamecaches)
int: nr "n" of gamecaches
"n" gamecache structures

1
2
3
4
string: gamecache name
int: reserved (currently nr of categories)
int: nr "m" of categories
"m" category structures

1
2
3
4
5
6
7
8
9
10
11
12
string: category name
int[5]: reserved for additional variable types
int: nr "i" integers
"i" integer structures
int: nr "r" reals
"r" real structures
int: nr "b" booleans
"b" boolean structures
int: nr "u" units
"u" unit structures
int: nr "s" strings
"s" string structures

1
2
string: label name
byte[4]: four bytes for the value

1
2
string: label name
string: value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
string: lable name
int: unit id
int: nr "j" inventory slots
"j" inventory slot structures
int: experience
int: level
int: unused skill points
int[9]: unknown
int: nr "k" hero skills
"k" hero skill structures
int[2]: unknown
float: unknown
int[4]: unknown
short: unknown

1
2
3
int: item id
int: nr charges
int: unknown

1
2
int: ability id
int: current level

1
2
3
4
5
6
7
int: unknown1: set to 0x64000000
int: unknown2: set to 0x03000000
"n" times a CRC32, "n" is the number of used slots (=files) in the MPQ archive
So for each file we have the CRC32 (cycling redundancy check) value here, wich is a sort of checksum, you can find functions that calculate the CRC32 of a file on the web
"n" times a Filetime, "n" is the number of used slots (=files) in the MPQ archive
The Filetime specifies for each file when it was added to the archive. It consists of two ints (low and high date/time). These two integers include information about the year, month, day, hour, minute and second when each file has been added, these 2 values represent a WinAPI file time structure and can be converted to the WinAPI system time type by using the SystemTimeToFileTime and FileTimeToSystemTime functions in kernel32.dllint: 
int: low date time

1
2
3
4
5
6
7
8
9
QuantamMPQFormat.txt
KMKMdxFormat.txt
MagosMdxFormat.txt
NubMdxFormat.txt
MagosBlpFormat.txt
W3GFormat.txt
W3GActions.txt
SLKFormat.txt
TGAFormat.txt