Packet

TRN.ASWM packets are used to store the walkmesh information in TRN and TRX files.

The packet itself is stored as is:

Uncompressed walkmesh data can be retrieved using zlib.deflate. The following structure information are for the uncompressed walkmesh data.

TRN/TRX differences

TRN.ASWM is slightly different weather it is stored in a TRX or TRN file. Generally, the TRX version is smaller as it has to be downloaded/loaded by the client, and contains the baked version of the walkmesh (with placeable walkmesh/walkmesh cutter alterations).

• TRN version:
  • The whole map is stored, but no information on placeable walkmeshes nor walkmesh cutters
  • Triangle clockwise flag is not set
  • Contains map border geometry
  • Path tables & island list are empty
• TRX version:
  • Baked counterpart of the TRN version
  • Map borders are not stored, only the center.
  • Triangles cut by a "walkmesh cutter" are removed (creates holes in the mesh)
  • Placeable walkmesh modifications appears
  • Path tables & island list are populated

Data blocks

Header struct (53 bytes)

Vertex struct (12 bytes)

Edge struct (16 bytes)

Notes

• The struct defines a edge between two triangles, with the shared edge.
• Every triangle has 3 Edge structs.
• Probably only used to ease path tables generation
• TODO: I should try remove all Edges from a baked trx and see what happens

Triangle struct (64 bytes)

• linked_triangles[i] and linked_edges[i] must share the same edge

Triangle flags

• walkable = 0x01: if the triangle can be walked on
• clockwise = 0x04: vertices are wound clockwise and not ccw
• dirt = 0x08: Floor type (for sound effects)
• grass = 0x10: Floor type (for sound effects)
• stone = 0x20: Floor type (for sound effects)
• wood = 0x40: Floor type (for sound effects)
• carpet = 0x80: Floor type (for sound effects)
• metal = 0x100: Floor type (for sound effects)
• swamp = 0x200: Floor type (for sound effects)
• mud = 0x400: Floor type (for sound effects)
• leaves = 0x800: Floor type (for sound effects)
• water = 0x1000: Floor type (for sound effects)
• puddles = 0x2000: Floor type (for sound effects)

island & walkable flag

• In TRN files:
  • Map border megatiles triangles have island=-1 and walkable flag set to 0
  • Bakeable triangles (map center) have a valid island (ie: != -1), and the walkable flag set to 1/0 if the triangle is meant to be walkable/non walkable.
• In TRX files:
  • Map borders are not stored
  • Non walkable triangles have island=-1 and walkable flag set to 0
  • Triangles cut by a "walkmesh cutter" are not stored

Notes

• For the raw map:
  • unknownA is always 0 (or -0)
• For the icy peak map
  • -498.294 ==> 475.229

TilesHeader struct (20 bytes)

Tile struct (variable length)

A tile is a square (generally 10 x 10 meters) containing mesh triangles. In TRX files, the tiles also contains pre-calculated pathfinding information.

• All triangles of a tile must have consecutive indices
• The triangle owned by a tile can be retrieved using aswm.triangles[header.triangles_offset .. header.triangles_offset + header.triangles_count]
• A tile must not re-use triangles owned by another tile (will crash NWN2)
• TODO: I need to try making non-square tiles and see how the game handles it

Tile path table

This is a pre-calculated pathfinding table, that reference the next triangle to go to in order to reach any other triangle of the tile.

This is how a path on a tile is calculated:

1. Get local triangle indices:
   • fromLocIdx = fromGlobIdx - tile.header.triangles_offset for the starting triangle
   • destLocIdx = destGlobIdx - tile.header.triangles_offset for the triangle you are trying to reach
   • If fromLocIdx or destLocIdx equals 255, it means the triangle is not walkable
2. Get node indices:
   • fromNodeIdx = tile.local_to_node[fromLocIdx]
   • destNodeIdx = tile.local_to_node[destLocIdx]
3. Get the Node value
   • node = tile.nodes[fromNodeIdx * header.node_to_local_length + destNodeIdx]
   • node == 255 can mean two things:
     • Destination cannot be reached, because one of the triangles is non- walkable or there is an obstacle that can't be get around without leaving the tile.
     • If fromNodeIdx == destNodeIdx, this means you already reached the destination triangle
4. Get the next local triangle index to go to in order to reach destination
   • nextLocIdx = tile.node_to_local[node & 0b0111_1111]
5. Loop on 2. with fromNodeIdx = nextLocIdx, until nextLocIdx == destNodeIdx

Notes:

• nodes[i] & 0b1000_0000 is a bit flag for if there is a clear line of sight between the two triangle. It's not clear what LOS is since two linked triangles on flat ground may not have LOS = 1 in game files. A value of 0 means the game will have to calculate LOS in real time.

TileHeader struct (57 bytes)

PathTableHeader struct (13 bytes)

• compression_flags values: rle = 1, zcompress = 2

Island struct (variable length)

An island is a fraction of a tile, where all walkable triangles can be reached without leaving the tile. This is a pathfinding related struct that is not available in TRN files.

• linked_islands_dist[i] and linked_islands_exit[i] are the distance & exit to linked_islands[i]
• I don't see the point of storing 3 times the same length. Maybe the nwn2 devs did not have time clean this.

IslandHeader struct (24 bytes)

IslandPathNode struct (8 bytes)

Pathfinding across islands works very similarly to Tile path table.

aswm.islands_path_nodes[fromIslandIdx * aswm.islands_length + toIslandIdx] is the next island to go to in order to reach toIslandIdx from fromIslandIdx