wc3maptranslator 3.0.3 → 4.0.1

package/lib/translators/TerrainTranslator.ts

@@ -1,13 +1,23 @@
 import { HexBuffer } from '../HexBuffer';
 import { W3Buffer } from '../W3Buffer';
+import { WarResult, JsonResult } from '../CommonInterfaces'
 
 interface Terrain {
     tileset: string;
-    customtileset: boolean;
-    tilepalette: string[];
-    clifftilepalette: string[];
+    customTileset: boolean;
+    tilePalette: string[];
+    cliffTilePalette: string[];
     map: Map;
-    tiles: any;
+    // "Masks"
+    groundHeight: number[],
+    waterHeight: number[],
+    boundaryFlag: boolean[],
+    flags: number[],
+    groundTexture: number[],
+    groundVariation: number[],
+    cliffVariation: number[],
+    cliffTexture: number[],
+    layerHeight: number[]
 }
 
 interface Map {
@@ -21,83 +31,118 @@ interface Offset {
     y: number;
 }
 
-export class TerrainTranslator {
-
-    private _outBufferToWar: HexBuffer;
-    private _outBufferToJSON: W3Buffer;
+function splitLargeArrayIntoWidthArrays(array: any[], width: number) {
+    const rows = [];
+    for(let i = 0; i < array.length / width; i++) {
+        rows.push(array.slice(i * width, (i+1) * width));
+    }
+    return rows;
+}
 
-    constructor() { }
+export abstract class TerrainTranslator {
 
-    public jsonToWar(terrainJson: Terrain) {
-        this._outBufferToWar = new HexBuffer();
+    public static jsonToWar(terrainJson: Terrain): WarResult {
+        const outBufferToWar = new HexBuffer();
 
         /*
          * Header
          */
-        this._outBufferToWar.addString('W3E!'); // file id
-        this._outBufferToWar.addInt(11); // file version
-        this._outBufferToWar.addChar(terrainJson.tileset); // base tileset
-        this._outBufferToWar.addInt(+terrainJson.customtileset); // 1 = using custom tileset, 0 = not
+        outBufferToWar.addChars('W3E!'); // file id
+        outBufferToWar.addInt(11); // file version
+        outBufferToWar.addChar(terrainJson.tileset); // base tileset
+        outBufferToWar.addInt(+terrainJson.customTileset); // 1 = using custom tileset, 0 = not
 
         /*
          * Tiles
          */
-        this._outBufferToWar.addInt(terrainJson.tilepalette.length);
-        terrainJson.tilepalette.forEach((tile) => {
-            this._outBufferToWar.addString(tile);
+        outBufferToWar.addInt(terrainJson.tilePalette.length);
+        terrainJson.tilePalette.forEach((tile) => {
+            outBufferToWar.addChars(tile);
         });
 
         /*
          * Cliffs
          */
-        this._outBufferToWar.addInt(terrainJson.clifftilepalette.length);
-        terrainJson.clifftilepalette.forEach((clifftile) => {
-            this._outBufferToWar.addString(clifftile);
+        outBufferToWar.addInt(terrainJson.cliffTilePalette.length);
+        terrainJson.cliffTilePalette.forEach((cliffTile) => {
+            outBufferToWar.addChars(cliffTile);
         });
 
         /*
          * Map size data
          */
-        this._outBufferToWar.addInt(terrainJson.map.width + 1);
-        this._outBufferToWar.addInt(terrainJson.map.height + 1);
+        outBufferToWar.addInt(terrainJson.map.width + 1);
+        outBufferToWar.addInt(terrainJson.map.height + 1);
 
-        // map offset
-        this._outBufferToWar.addFloat(terrainJson.map.offset.x);
-        this._outBufferToWar.addFloat(terrainJson.map.offset.y);
+        /*
+         * Map offset
+         */
+        outBufferToWar.addFloat(terrainJson.map.offset.x);
+        outBufferToWar.addFloat(terrainJson.map.offset.y);
 
         /*
          * Tile points
          */
-        for (let i = terrainJson.tiles.length - 1; i >= 0; i--) {
-            // write each for of tiles
-            // tslint:disable-next-line: prefer-for-of
-            for (let width = 0; width < terrainJson.tiles[i].length; width++) {
-                const currTile = terrainJson.tiles[i][width];
+        // Partition the terrainJson masks into "chunks" (i.e. rows) of (width+1) length,
+        // reverse that list of rows (due to vertical flipping), and then write the rows out
+        const rows = {
+            groundHeight: splitLargeArrayIntoWidthArrays(terrainJson.groundHeight, terrainJson.map.width + 1),
+            waterHeight: splitLargeArrayIntoWidthArrays(terrainJson.waterHeight, terrainJson.map.width + 1),
+            boundaryFlag: splitLargeArrayIntoWidthArrays(terrainJson.boundaryFlag, terrainJson.map.width + 1),
+            flags: splitLargeArrayIntoWidthArrays(terrainJson.flags, terrainJson.map.width + 1),
+            groundTexture: splitLargeArrayIntoWidthArrays(terrainJson.groundTexture, terrainJson.map.width + 1),
+            groundVariation: splitLargeArrayIntoWidthArrays(terrainJson.groundVariation, terrainJson.map.width + 1),
+            cliffVariation: splitLargeArrayIntoWidthArrays(terrainJson.cliffVariation, terrainJson.map.width + 1),
+            cliffTexture: splitLargeArrayIntoWidthArrays(terrainJson.cliffTexture, terrainJson.map.width + 1),
+            layerHeight: splitLargeArrayIntoWidthArrays(terrainJson.layerHeight, terrainJson.map.width + 1)
+        };
 
-                const boundaryFlag = currTile.boundaryFlag ? 0x4000 : 0;
+        rows.groundHeight.reverse();
+        rows.waterHeight.reverse();
+        rows.boundaryFlag.reverse();
+        rows.flags.reverse();
+        rows.groundTexture.reverse();
+        rows.groundVariation.reverse();
+        rows.cliffVariation.reverse();
+        rows.cliffTexture.reverse();
+        rows.layerHeight.reverse();
 
+        for(let i = 0; i < rows.groundHeight.length; i++) {
+            for(let j = 0; j < rows.groundHeight[i].length; j++) {
                 // these bit operations are based off documentation from https://github.com/stijnherfst/HiveWE/wiki/war3map.w3e-Terrain
-                this._outBufferToWar.addShort(currTile.groundHeight); // height
-                this._outBufferToWar.addShort(currTile.waterHeight | boundaryFlag); // water
-                this._outBufferToWar.addByte(currTile.flags | currTile.groundTexture);
-                this._outBufferToWar.addByte(currTile.groundVariation | currTile.cliffVariation);
-                this._outBufferToWar.addByte(currTile.cliffTexture | currTile.layerHeight);
+                const groundHeight = rows.groundHeight[i][j];
+                const waterHeight = rows.waterHeight[i][j];
+                const boundaryFlag = rows.boundaryFlag[i][j];
+                const flags = rows.flags[i][j];
+                const groundTexture = rows.groundTexture[i][j];
+                const groundVariation = rows.groundVariation[i][j];
+                const cliffVariation = rows.cliffVariation[i][j];
+                const cliffTexture = rows.cliffTexture[i][j];
+                const layerHeight = rows.layerHeight[i][j];
+
+                const hasBoundaryFlag = boundaryFlag ? 0x4000 : 0;
+
+                outBufferToWar.addShort(groundHeight);
+                outBufferToWar.addShort(waterHeight | hasBoundaryFlag);
+                outBufferToWar.addByte(flags | groundTexture);
+                outBufferToWar.addByte(groundVariation | cliffVariation);
+                outBufferToWar.addByte(cliffTexture | layerHeight);
             }
         }
 
         return {
             errors: [],
-            buffer: this._outBufferToWar.getBuffer()
+            buffer: outBufferToWar.getBuffer()
         };
     }
 
-    public warToJson(buffer: Buffer) {
+    public static warToJson(buffer: Buffer): JsonResult<Terrain> {
         // create buffer
         const result: Terrain = {
             tileset: '',
-            customtileset: false,
-            tilepalette: [],
-            clifftilepalette: [],
+            customTileset: false,
+            tilePalette: [],
+            cliffTilePalette: [],
             map: {
                 width: 1,
                 height: 1,
@@ -106,98 +151,122 @@ export class TerrainTranslator {
                     y: 0
                 }
             },
-            tiles: {}
+            groundHeight: [],
+            waterHeight: [],
+            boundaryFlag: [],
+            flags: [],
+            groundTexture: [],
+            groundVariation: [],
+            cliffVariation: [],
+            cliffTexture: [],
+            layerHeight: []
         };
-        this._outBufferToJSON = new W3Buffer(buffer);
+        const outBufferToJSON = new W3Buffer(buffer);
 
         /**
          * Header
          */
-        const w3eHeader = this._outBufferToJSON.readChars(4); // W3E!
-        const version = this._outBufferToJSON.readInt(); // 0B 00 00 00
-        const tileset = this._outBufferToJSON.readChars(1); // tileset
-        const customtileset = (this._outBufferToJSON.readInt() === 1);
+        const w3eHeader = outBufferToJSON.readChars(4); // W3E!
+        const version = outBufferToJSON.readInt(); // 0B 00 00 00
+        const tileset = outBufferToJSON.readChars(1); // tileset
+        const customTileset = (outBufferToJSON.readInt() === 1);
 
         result.tileset = tileset;
-        result.customtileset = customtileset;
+        result.customTileset = customTileset;
 
         /**
          * Tiles
          */
-        const numTilePalettes = this._outBufferToJSON.readInt();
+        const numTilePalettes = outBufferToJSON.readInt();
         const tilePalettes = [];
         for (let i = 0; i < numTilePalettes; i++) {
-            tilePalettes.push(this._outBufferToJSON.readChars(4));
+            tilePalettes.push(outBufferToJSON.readChars(4));
         }
 
-        result.tilepalette = tilePalettes;
+        result.tilePalette = tilePalettes;
 
         /**
          * Cliffs
          */
-        const numCliffTilePalettes = this._outBufferToJSON.readInt();
+        const numCliffTilePalettes = outBufferToJSON.readInt();
         const cliffPalettes = [];
         for (let i = 0; i < numCliffTilePalettes; i++) {
-            const cliffPalette = this._outBufferToJSON.readChars(4);
+            const cliffPalette = outBufferToJSON.readChars(4);
             cliffPalettes.push(cliffPalette);
         }
 
-        result.clifftilepalette = cliffPalettes;
+        result.cliffTilePalette = cliffPalettes;
 
         /**
          * map dimensions
          */
-        const width = this._outBufferToJSON.readInt() - 1;
-        const height = this._outBufferToJSON.readInt() - 1;
+        const width = outBufferToJSON.readInt() - 1;
+        const height = outBufferToJSON.readInt() - 1;
         result.map = { width, height, offset: { x: 0, y: 0 } };
 
-        const offsetX = this._outBufferToJSON.readFloat();
-        const offsetY = this._outBufferToJSON.readFloat();
+        const offsetX = outBufferToJSON.readFloat();
+        const offsetY = outBufferToJSON.readFloat();
         result.map.offset = { x: offsetX, y: offsetY };
 
         /**
          * map tiles
          */
-        result.tiles = [];
-        for (let h = 0; h < height + 1; h++) {
-            const currRow = [];
-
-            for (let w = 0; w < width + 1; w++) {
-                // get the bytes from the buffer
-                const groundHeight = this._outBufferToJSON.readShort();
-                const waterHeightAndBoundary = this._outBufferToJSON.readShort();
-                const flagsAndGroundTexture = this._outBufferToJSON.readByte();
-                const groundAndCliffVariation = this._outBufferToJSON.readByte();
-                const cliffTextureAndLayerHeight = this._outBufferToJSON.readByte();
-
-                // parse out different bits (based on documentation from https://github.com/stijnherfst/HiveWE/wiki/war3map.w3e-Terrain)
-                const waterHeight = waterHeightAndBoundary & 32767;
-                const boundaryFlag = (waterHeightAndBoundary & 0x4000) === 0x4000;
-                const flags = flagsAndGroundTexture & 240;
-                const groundTexture = flagsAndGroundTexture & 15;
-                const groundVariation = groundAndCliffVariation & 248;
-                const cliffVariation = groundAndCliffVariation & 7;
-                const cliffTexture = cliffTextureAndLayerHeight & 240;
-                const layerHeight = cliffTextureAndLayerHeight & 15;
-
-                // add tile
-                currRow.push({
-                    groundHeight,
-                    waterHeight,
-                    boundaryFlag,
-                    flags,
-                    groundTexture,
-                    groundVariation,
-                    cliffVariation,
-                    cliffTexture,
-                    layerHeight
-                });
-            }
-            result.tiles.unshift(currRow);
+        const arr_groundHeight = [];
+        const arr_waterHeight = [];
+        const arr_boundaryFlag = [];
+        const arr_flags = [];
+        const arr_groundTexture = [];
+        const arr_groundVariation = [];
+        const arr_cliffVariation = [];
+        const arr_cliffTexture = [];
+        const arr_layerHeight = [];
+
+        while(!outBufferToJSON.isExhausted()) {
+            const groundHeight = outBufferToJSON.readShort();
+            const waterHeightAndBoundary = outBufferToJSON.readShort();
+            const flagsAndGroundTexture = outBufferToJSON.readByte();
+            const groundAndCliffVariation = outBufferToJSON.readByte();
+            const cliffTextureAndLayerHeight = outBufferToJSON.readByte();
+
+            // parse out different bits (based on documentation from https://github.com/stijnherfst/HiveWE/wiki/war3map.w3e-Terrain)
+            const waterHeight = waterHeightAndBoundary & 32767;
+            const boundaryFlag = (waterHeightAndBoundary & 0x4000) === 0x4000;
+            const flags = flagsAndGroundTexture & 240;
+            const groundTexture = flagsAndGroundTexture & 15;
+            const groundVariation = groundAndCliffVariation & 248;
+            const cliffVariation = groundAndCliffVariation & 7;
+            const cliffTexture = cliffTextureAndLayerHeight & 240;
+            const layerHeight = cliffTextureAndLayerHeight & 15;
+
+            arr_groundHeight.push(groundHeight);
+            arr_waterHeight.push(waterHeight);
+            arr_boundaryFlag.push(boundaryFlag);
+            arr_flags.push(flags);
+            arr_groundTexture.push(groundTexture);
+            arr_groundVariation.push(groundVariation);
+            arr_cliffVariation.push(cliffVariation);
+            arr_cliffTexture.push(cliffTexture);
+            arr_layerHeight.push(layerHeight);
+        }
+
+        function convertArrayOfArraysIntoFlatArray(arr) {
+            return arr.reduce((a, b) => {
+                return [...a, ...b]
+            });
         }
 
-        // tiles
-        // [0, 0, 0, 0, 0, 0, 0]
+        // The map was read in "backwards" because wc3 maps have origin (0,0)
+        // at the bottom left instead of top left as we desire. Flip the rows
+        // vertically to fix this.
+        result.groundHeight = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_groundHeight, result.map.width + 1).reverse())
+        result.waterHeight = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_waterHeight, result.map.width + 1).reverse())
+        result.boundaryFlag = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_boundaryFlag, result.map.width + 1).reverse())
+        result.flags = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_flags, result.map.width + 1).reverse())
+        result.groundTexture = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_groundTexture, result.map.width + 1).reverse())
+        result.groundVariation = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_groundVariation, result.map.width + 1).reverse())
+        result.cliffVariation = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_cliffVariation, result.map.width + 1).reverse())
+        result.cliffTexture = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_cliffTexture, result.map.width + 1).reverse())
+        result.layerHeight = convertArrayOfArraysIntoFlatArray(splitLargeArrayIntoWidthArrays(arr_layerHeight, result.map.width + 1).reverse())
 
         return {
             errors: [],