@wwawing/loader 0.0.0-exe-chousa.based-on.3.12.21

package/module/core/extractor/index.js

@@ -0,0 +1,182 @@
+import { new2DArray } from "../../infra/util";
+import { checkMapDataBroken } from "./checksum";
+import { BytePosition } from "./constants";
+import { WWAConsts, PartsType, LoadStage, createDefaultWWAData } from "../../infra";
+export class WWADataExtractor {
+    constructor(byteMapData, byteMapLength, eventEmitter) {
+        this.byteMapData = byteMapData;
+        this.eventEmitter = eventEmitter;
+        checkMapDataBroken(byteMapData, byteMapLength);
+        this.wwaData = createDefaultWWAData();
+    }
+    extractAllData() {
+        var mapAttrMax, objAttrMax;
+        this.wwaData.version = this.byteMapData[BytePosition.VERSION];
+        this._extractInitialParameters();
+        if (this.wwaData.version >= 29) {
+            this.currentPosition = BytePosition.MAPDATA_TOP;
+        }
+        else {
+            this.currentPosition = BytePosition.OLD_MAPDATA_TOP;
+        }
+        this.wwaData.map = this._getFieldDataFromBits(PartsType.MAP, this.wwaData.mapPartsMax).concat();
+        this.wwaData.mapObject = this._getFieldDataFromBits(PartsType.OBJECT, this.wwaData.objPartsMax).concat();
+        mapAttrMax = this.wwaData.version > 29 ? WWAConsts.MAP_ATR_MAX : WWAConsts.OLD_MAP_ATR_MAX;
+        objAttrMax = this.wwaData.version > 29 ? WWAConsts.OBJ_ATR_MAX : WWAConsts.OLD_OBJ_ATR_MAX;
+        this.wwaData.mapAttribute = this._getPartsDataFromBits(PartsType.MAP, this.wwaData.mapPartsMax, mapAttrMax).concat();
+        this.wwaData.objectAttribute = this._getPartsDataFromBits(PartsType.OBJECT, this.wwaData.objPartsMax, objAttrMax).concat();
+        if (this.wwaData.version <= 29) {
+            this._convertAttributeV2toV3(PartsType.MAP);
+            this._convertAttributeV2toV3(PartsType.OBJECT);
+        }
+        this._replaceAllRandomObjects();
+        return this.wwaData;
+    }
+    _convertAttributeV2toV3(partsType) {
+        var partsMax;
+        var attributeArray;
+        var localGateIndex;
+        if (partsType == PartsType.MAP) {
+            partsMax = this.wwaData.mapPartsMax;
+            attributeArray = this.wwaData.mapAttribute;
+            localGateIndex = WWAConsts.MAP_LOCALGATE;
+        }
+        else if (partsType == PartsType.OBJECT) {
+            partsMax = this.wwaData.objPartsMax;
+            attributeArray = this.wwaData.objectAttribute;
+            localGateIndex = WWAConsts.OBJECT_LOCALGATE;
+        }
+        else {
+            throw new Error("謎のパーツ種別が指定されました");
+        }
+        for (var j = 0; j < partsMax; j++) {
+            for (var i = 9; i >= 0; i--) {
+                var dataChara = attributeArray[j][20 + i * 2] & 0xff;
+                var dataMode = attributeArray[j][20 + i * 2] >> 8;
+                var x = attributeArray[j][20 + i * 2 + 1] & 0xff;
+                var y = attributeArray[j][20 + i * 2 + 1] >> 8;
+                if (x === 250) {
+                    x = 9000;
+                }
+                else if (x > 100) {
+                    x += 10000 - 160;
+                }
+                if (y === 250) {
+                    y = 9000;
+                }
+                else if (y > 100) {
+                    y += 10000 - 160;
+                }
+                attributeArray[j][20 + i * 4] = dataChara;
+                attributeArray[j][20 + i * 4 + 3] = dataMode;
+                attributeArray[j][20 + i * 4 + 1] = x;
+                attributeArray[j][20 + i * 4 + 2] = y;
+            }
+            if (attributeArray[j][WWAConsts.ATR_TYPE] === localGateIndex) {
+                if (attributeArray[j][WWAConsts.ATR_JUMP_X] > 100) {
+                    attributeArray[j][WWAConsts.ATR_JUMP_X] += 10000 - 160;
+                }
+                if (attributeArray[j][WWAConsts.ATR_JUMP_Y] > 100) {
+                    attributeArray[j][WWAConsts.ATR_JUMP_Y] += 10000 - 160;
+                }
+            }
+        }
+    }
+    _get1ByteNumber(index) {
+        return this.byteMapData[index];
+    }
+    _get2BytesNumber(index) {
+        return this.byteMapData[index] + this.byteMapData[index + 1] * 0x100;
+    }
+    _extractInitialParameters() {
+        if (this.wwaData.version > 29) {
+            this.wwaData.gameoverX = this._get2BytesNumber(BytePosition.GAMEOVER_X);
+            this.wwaData.gameoverY = this._get2BytesNumber(BytePosition.GAMEOVER_Y);
+            this.wwaData.playerX = this._get2BytesNumber(BytePosition.PLAYER_X);
+            this.wwaData.playerY = this._get2BytesNumber(BytePosition.PLAYER_Y);
+            this.wwaData.mapPartsMax = this._get2BytesNumber(BytePosition.MAP_COUNT);
+            this.wwaData.objPartsMax = this._get2BytesNumber(BytePosition.OBJ_COUNT);
+            this.wwaData.isOldMap = false;
+        }
+        else {
+            this.wwaData.gameoverX = this._get1ByteNumber(BytePosition.OLD_GAMEOVER_X);
+            this.wwaData.gameoverY = this._get1ByteNumber(BytePosition.OLD_GAMEOVER_Y);
+            this.wwaData.playerX = this._get1ByteNumber(BytePosition.OLD_PLAYER_X);
+            this.wwaData.playerY = this._get1ByteNumber(BytePosition.OLD_PLAYER_Y);
+            this.wwaData.mapPartsMax = this._get1ByteNumber(BytePosition.OLD_MAP_COUNT);
+            this.wwaData.objPartsMax = this._get1ByteNumber(BytePosition.OLD_OBJ_COUNT);
+            this.wwaData.isOldMap = true;
+        }
+        this.wwaData.statusEnergyMax = this._get2BytesNumber(BytePosition.STATUS_ENERGY_MAX);
+        this.wwaData.statusEnergy = this._get2BytesNumber(BytePosition.STATUS_ENERGY);
+        this.wwaData.statusStrength = this._get2BytesNumber(BytePosition.STATUS_STRENGTH);
+        this.wwaData.statusDefence = this._get2BytesNumber(BytePosition.STATUS_DEFENCE);
+        this.wwaData.statusGold = this._get2BytesNumber(BytePosition.STATUS_GOLD);
+        this._extractInitialItemData();
+        this.wwaData.mapWidth = this._get2BytesNumber(BytePosition.MAP_SIZE);
+        this.wwaData.messageNum = this._get2BytesNumber(BytePosition.MESSAGE_NUM);
+        if (this.wwaData.version < 28)
+            this.wwaData.mapWidth = 71;
+        else if (this.wwaData.version <= 29)
+            this.wwaData.mapWidth = 101;
+    }
+    _extractInitialItemData() {
+        const topIdx = this.wwaData.version > 29 ? BytePosition.ITEMBOX_TOP : BytePosition.OLD_ITEMBOX_TOP;
+        this.wwaData.itemBox = new Array(WWAConsts.ITEMBOX_SIZE);
+        for (let i = 0; i < WWAConsts.ITEMBOX_SIZE; i++) {
+            this.wwaData.itemBox[i] = this._get1ByteNumber(topIdx + i);
+        }
+    }
+    _getFieldDataFromBits(partsType, partsMax) {
+        var x, y;
+        var fieldArray;
+        fieldArray = new2DArray(this.wwaData.mapWidth, this.wwaData.mapWidth);
+        for (x = 0; x < this.wwaData.mapWidth; x++) {
+            for (y = 0; y < this.wwaData.mapWidth; y++) {
+                if (this.wwaData.version > 29) {
+                    fieldArray[x][y] = this._get2BytesNumber(this.currentPosition);
+                    this.currentPosition += 2;
+                }
+                else {
+                    fieldArray[x][y] = this._get1ByteNumber(this.currentPosition);
+                    this.currentPosition += 1;
+                }
+                if ((x * this.wwaData.mapWidth + y) % 200 === 0) {
+                    this.emitProgress(x * this.wwaData.mapWidth + y, this.wwaData.mapWidth * this.wwaData.mapWidth, partsType === PartsType.MAP ? LoadStage.MAP_LOAD : LoadStage.OBJ_LOAD);
+                }
+                if (fieldArray[x][y] >= partsMax) {
+                    fieldArray[x][y] = 0;
+                }
+            }
+        }
+        this.emitProgress(this.wwaData.mapWidth * this.wwaData.mapWidth, this.wwaData.mapWidth * this.wwaData.mapWidth, partsType === PartsType.MAP ? LoadStage.MAP_LOAD : LoadStage.OBJ_LOAD);
+        return fieldArray;
+    }
+    _getPartsDataFromBits(partsType, partsMax, attrMax) {
+        var i, j;
+        var partsData;
+        partsData = new2DArray(partsMax, attrMax);
+        for (i = 0; i < partsMax; i++) {
+            for (j = 0; j < attrMax; j++) {
+                if ((i * this.wwaData.mapWidth + j) % 200 === 0) {
+                    this.emitProgress(i * attrMax + j, partsMax * attrMax, partsType === PartsType.MAP ? LoadStage.MAP_ATTR : LoadStage.OBJ_ATTR);
+                }
+                if (j === WWAConsts.ATR_CROP1 || j === WWAConsts.ATR_CROP2) {
+                    partsData[i][j] = 0;
+                    this.currentPosition += 2;
+                    continue;
+                }
+                partsData[i][j] = this._get2BytesNumber(this.currentPosition);
+                this.currentPosition += 2;
+            }
+        }
+        this.emitProgress(partsMax * attrMax, partsMax * attrMax, partsType === PartsType.MAP ? LoadStage.MAP_ATTR : LoadStage.OBJ_ATTR);
+        return partsData;
+    }
+    _replaceAllRandomObjects() {
+        this.emitProgress(this.wwaData.mapWidth * this.wwaData.mapWidth, this.wwaData.mapWidth * this.wwaData.mapWidth, LoadStage.RAND_PARTS);
+    }
+    emitProgress(current, total, stage) {
+        this.eventEmitter.dispatch("progress", { current, total, stage });
+    }
+}

package/module/core/index.d.ts

@@ -0,0 +1,8 @@
+import { WWALoaderEventEmitter } from "../infra";
+export declare class WWALoader {
+    private fileName;
+    private eventEmitter;
+    constructor(fileName: string, eventEmitter: WWALoaderEventEmitter);
+    requestAndLoadMapData(): Promise<void>;
+    private loadMapData;
+}

package/module/core/index.js

@@ -0,0 +1,46 @@
+import { WWADataExtractor } from "./extractor";
+import { decompressMapData } from "./decompressor";
+import { TextLoader } from "./text-loader";
+import { BrowserMapDataClient, NodeLocalMapDataClient } from "./map-data-client";
+const createMapDataClient = (fileName) => {
+    if (typeof window !== "undefined") {
+        return new BrowserMapDataClient(fileName);
+    }
+    else {
+        return new NodeLocalMapDataClient(fileName);
+    }
+};
+export class WWALoader {
+    constructor(fileName, eventEmitter) {
+        this.fileName = fileName;
+        this.eventEmitter = eventEmitter;
+    }
+    async requestAndLoadMapData() {
+        const client = createMapDataClient(this.fileName);
+        try {
+            const responseBuffer = await client.request();
+            if (!responseBuffer) {
+                this.eventEmitter.dispatch("error", { name: "マップデータ取得に失敗しました", message: "mapdata is empty" });
+                return;
+            }
+            const wwaData = this.loadMapData(responseBuffer);
+            this.eventEmitter.dispatch("mapData", wwaData);
+        }
+        catch (error) {
+            const name = error.name || "";
+            const message = error.message || "";
+            this.eventEmitter.dispatch("error", { name, message });
+        }
+    }
+    loadMapData(data) {
+        try {
+            const compressedByteMapData = new Uint8Array(data);
+            const { byteMapData, byteMapLength, compressedEndPosition } = decompressMapData(compressedByteMapData);
+            const wwaData = new WWADataExtractor(byteMapData, byteMapLength, this.eventEmitter).extractAllData();
+            return new TextLoader(wwaData, compressedByteMapData, compressedEndPosition, this.eventEmitter).load();
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+}

package/module/core/map-data-client/BaseMapDataClient.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class BaseMapDataClient {
+    constructor();
+    abstract request(): Promise<ArrayBufferLike>;
+}

package/module/core/map-data-client/BaseMapDataClient.js

@@ -0,0 +1,3 @@
+export class BaseMapDataClient {
+    constructor() { }
+}

package/module/core/map-data-client/BrowserMapDataClient.d.ts

@@ -0,0 +1,8 @@
+import { BaseMapDataClient } from "./BaseMapDataClient";
+export declare class BrowserMapDataClient extends BaseMapDataClient {
+    private uri;
+    constructor(uri: string);
+    private static fetch;
+    private static handleError;
+    request(): Promise<ArrayBufferLike>;
+}

package/module/core/map-data-client/BrowserMapDataClient.js

@@ -0,0 +1,41 @@
+import { BaseMapDataClient } from "./BaseMapDataClient";
+export class BrowserMapDataClient extends BaseMapDataClient {
+    constructor(uri) {
+        super();
+        this.uri = uri;
+    }
+    static async fetch(uri) {
+        try {
+            return await fetch(uri);
+        }
+        catch (error) {
+            throw new Error(`マップデータ 「${uri}」の読み込みに失敗しました。
+        通信環境の良いところで再度お試しください。
+        ローカルテストの場合は、ブラウザが対応していない可能性があります。`);
+        }
+    }
+    static handleError(uri, response) {
+        const statusCodeMessage = `HTTPステータスコードは ${response.status} です。`;
+        switch (response.status) {
+            case 200:
+            case 304:
+                return;
+            case 403:
+                throw new Error(`マップデータ「${uri}」を読み取る権限がないようです。
+          管理者の方へ: マップデータのパーミッションを確認してください。
+          ${statusCodeMessage}`);
+            case 404:
+                throw new Error(`マップデータ「${uri}」が見つかりませんでした。
+          ${statusCodeMessage}`);
+            default:
+                throw new Error(`マップデータ「${uri}」の読み込みに失敗しました。
+          ${statusCodeMessage}`);
+        }
+    }
+    async request() {
+        const response = await BrowserMapDataClient.fetch(this.uri);
+        BrowserMapDataClient.handleError(this.uri, response);
+        const buffer = await response.arrayBuffer();
+        return buffer;
+    }
+}

package/module/core/map-data-client/NodeLocalMapDataClient.d.ts

@@ -0,0 +1,6 @@
+import { BaseMapDataClient } from "./BaseMapDataClient";
+export declare class NodeLocalMapDataClient extends BaseMapDataClient {
+    private fileName;
+    constructor(fileName: string);
+    request(): Promise<ArrayBufferLike>;
+}

package/module/core/map-data-client/NodeLocalMapDataClient.js

@@ -0,0 +1,19 @@
+import fs from "fs";
+import { BaseMapDataClient } from "./BaseMapDataClient";
+export class NodeLocalMapDataClient extends BaseMapDataClient {
+    constructor(fileName) {
+        super();
+        this.fileName = fileName;
+    }
+    async request() {
+        return new Promise((resolve, reject) => {
+            fs.readFile(this.fileName, (error, data) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve(data.buffer);
+            });
+        });
+    }
+    ;
+}

package/module/core/map-data-client/index.d.ts

@@ -0,0 +1,4 @@
+import { BaseMapDataClient } from "./BaseMapDataClient";
+import { BrowserMapDataClient } from "./BrowserMapDataClient";
+import { NodeLocalMapDataClient } from "./NodeLocalMapDataClient";
+export { BaseMapDataClient, BrowserMapDataClient, NodeLocalMapDataClient };

package/module/core/map-data-client/index.js

@@ -0,0 +1,4 @@
+import { BaseMapDataClient } from "./BaseMapDataClient";
+import { BrowserMapDataClient } from "./BrowserMapDataClient";
+import { NodeLocalMapDataClient } from "./NodeLocalMapDataClient";
+export { BaseMapDataClient, BrowserMapDataClient, NodeLocalMapDataClient };

package/module/core/text-loader/index.d.ts

@@ -0,0 +1,13 @@
+import { WWALoaderEventEmitter } from "../../infra";
+import { WWAData } from "@wwawing/common-interface";
+export declare class TextLoader {
+    private wwaData;
+    private compressedMapData;
+    private startPosition;
+    private eventEmitter;
+    readonly OLDVER_MESSAGE_MAX: number;
+    private currentPos;
+    constructor(wwaData: WWAData, compressedMapData: Uint8Array, startPosition: number, eventEmitter: WWALoaderEventEmitter);
+    load(): WWAData;
+    private getMessageFromData;
+}

package/module/core/text-loader/index.js

@@ -0,0 +1,143 @@
+import { LoadStage, WWAConsts } from "../../infra";
+export class TextLoader {
+    constructor(wwaData, compressedMapData, startPosition, eventEmitter) {
+        this.wwaData = wwaData;
+        this.compressedMapData = compressedMapData;
+        this.startPosition = startPosition;
+        this.eventEmitter = eventEmitter;
+        this.OLDVER_MESSAGE_MAX = 400;
+    }
+    load() {
+        const wwaData = this.wwaData;
+        this.currentPos = this.startPosition;
+        if (wwaData.version >= 30) {
+            wwaData.worldPassword = this.getMessageFromData();
+        }
+        if (wwaData.version <= 29) {
+            wwaData.messageNum = this.OLDVER_MESSAGE_MAX;
+        }
+        wwaData.message = new Array(wwaData.messageNum);
+        for (let i = 0; i < wwaData.message.length; i++) {
+            wwaData.message[i] = this.getMessageFromData();
+            if (i % 200 === 0) {
+                this.eventEmitter.dispatch("progress", {
+                    current: i,
+                    total: wwaData.message.length,
+                    stage: LoadStage.MESSAGE
+                });
+            }
+        }
+        while (wwaData.messageNum < 10) {
+            wwaData.message.push("");
+            wwaData.messageNum++;
+        }
+        this.eventEmitter.dispatch("progress", {
+            current: wwaData.message.length,
+            total: wwaData.message.length,
+            stage: LoadStage.MESSAGE
+        });
+        wwaData.worldName = this.getMessageFromData();
+        if (wwaData.version <= 29) {
+            wwaData.worldPassword = this.getMessageFromData();
+        }
+        else {
+            this.getMessageFromData();
+        }
+        if (wwaData.worldPassword === "") {
+            wwaData.worldPassNumber = 0;
+        }
+        else {
+            if (wwaData.version >= 29) {
+                wwaData.worldPassNumber =
+                    (parseInt(wwaData.worldPassword) / 10 - 1197) / 17 - 2357;
+            }
+            else {
+                wwaData.worldPassNumber = parseInt(wwaData.worldPassword);
+            }
+        }
+        wwaData.charCGName = this.getMessageFromData();
+        wwaData.mapCGName = this.getMessageFromData();
+        wwaData.systemMessage = new Array(WWAConsts.SYSTEM_MESSAGE_NUM);
+        for (let i = 0; i < WWAConsts.SYSTEM_MESSAGE_NUM; i++) {
+            if (wwaData.version >= 30) {
+                wwaData.systemMessage[i] = this.getMessageFromData();
+            }
+            else {
+                wwaData.systemMessage[i] = "";
+            }
+        }
+        wwaData.yesnoImgPosX = WWAConsts.IMGPOS_DEFAULT_YESNO_X;
+        wwaData.yesnoImgPosY = WWAConsts.IMGPOS_DEFAULT_YESNO_Y;
+        wwaData.playerImgPosX = WWAConsts.IMGPOS_DEFAULT_PLAYER_X;
+        wwaData.playerImgPosY = WWAConsts.IMGPOS_DEFAULT_PLAYER_Y;
+        wwaData.clickableItemSignImgPosX = WWAConsts.IMGPOS_DEFAULT_CLICKABLE_ITEM_SIGN_X;
+        wwaData.clickableItemSignImgPosY = WWAConsts.IMGPOS_DEFAULT_CLICKABLE_ITEM_SIGN_Y;
+        wwaData.disableSaveFlag = WWAConsts.DEFAULT_DISABLE_SAVE;
+        wwaData.isOldMap = WWAConsts.DEFAULT_OLDMAP;
+        wwaData.isOldMove = wwaData.version < 31;
+        wwaData.objectNoCollapseDefaultFlag = WWAConsts.DEFAULT_OBJECT_NO_COLLAPSE;
+        wwaData.delPlayerFlag = false;
+        wwaData.bgm = 0;
+        wwaData.effectCoords = [];
+        wwaData.effectWaits = 0;
+        wwaData.imgStatusEnergyX = WWAConsts.IMGPOS_DEFAULT_STATUS_X + WWAConsts.IMGRELPOS_ENERGY_ICON_X;
+        wwaData.imgStatusEnergyY = WWAConsts.IMGPOS_DEFAULT_STATUS_Y;
+        wwaData.imgStatusStrengthX = WWAConsts.IMGPOS_DEFAULT_STATUS_X + WWAConsts.IMGRELPOS_STRENGTH_ICON_X;
+        wwaData.imgStatusStrengthY = WWAConsts.IMGPOS_DEFAULT_STATUS_Y;
+        wwaData.imgStatusDefenceX = WWAConsts.IMGPOS_DEFAULT_STATUS_X + WWAConsts.IMGRELPOS_DEFENCE_ICON_X;
+        wwaData.imgStatusDefenceY = WWAConsts.IMGPOS_DEFAULT_STATUS_Y;
+        wwaData.imgStatusGoldX = WWAConsts.IMGPOS_DEFAULT_STATUS_X + WWAConsts.IMGRELPOS_GOLD_ICON_X;
+        wwaData.imgStatusGoldY = WWAConsts.IMGPOS_DEFAULT_STATUS_Y;
+        wwaData.imgWideCellX = WWAConsts.IMGPOS_DEFAULT_WIDE_CELL_X;
+        wwaData.imgWideCellY = WWAConsts.IMGPOS_DEFAULT_WIDE_CELL_Y;
+        wwaData.imgItemboxX = WWAConsts.IMGPOS_DEFAULT_ITEMBOX_X;
+        wwaData.imgItemboxY = WWAConsts.IMGPOS_DEFAULT_ITEMBOX_Y;
+        wwaData.imgFrameX = WWAConsts.IMGPOS_DEFAULT_FRAME_X;
+        wwaData.imgFrameY = WWAConsts.IMGPOS_DEFAULT_FRAME_Y;
+        wwaData.imgBattleEffectX = WWAConsts.IMGPOS_DEFAULT_BATTLE_EFFECT_X;
+        wwaData.imgBattleEffectY = WWAConsts.IMGPOS_DEFAULT_BATTLE_EFFECT_Y;
+        wwaData.imgClickX = 0;
+        wwaData.imgClickY = 0;
+        wwaData.frameColorR = WWAConsts.DEFAULT_FRAME_COLOR_R;
+        wwaData.frameColorG = WWAConsts.DEFAULT_FRAME_COLOR_G;
+        wwaData.frameColorB = WWAConsts.DEFAULT_FRAME_COLOR_B;
+        wwaData.frameOutColorR = WWAConsts.DEFAULT_FRAMEOUT_COLOR_R;
+        wwaData.frameOutColorG = WWAConsts.DEFAULT_FRAMEOUT_COLOR_G;
+        wwaData.frameOutColorB = WWAConsts.DEFAULT_FRAMEOUT_COLOR_B;
+        wwaData.fontColorR = WWAConsts.DEFAULT_STR_COLOR_R;
+        wwaData.fontColorG = WWAConsts.DEFAULT_STR_COLOR_G;
+        wwaData.fontColorB = WWAConsts.DEFAULT_STR_COLOR_B;
+        wwaData.statusColorR = WWAConsts.DEFAULT_STATUS_COLOR_R;
+        wwaData.statusColorG = WWAConsts.DEFAULT_STATUS_COLOR_G;
+        wwaData.statusColorB = WWAConsts.DEFAULT_STATUS_COLOR_B;
+        wwaData.moves = WWAConsts.DEFAULT_MOVES;
+        wwaData.gameSpeedIndex = WWAConsts.DEFAULT_SPEED_INDEX;
+        wwaData.permitChangeGameSpeed = true;
+        wwaData.userVar = new Array(WWAConsts.USER_VAR_NUM);
+        for (let i = 0; i < WWAConsts.USER_VAR_NUM; i++) {
+            wwaData.userVar[i] = 0;
+        }
+        wwaData.playTime = 0;
+        wwaData.isVisibleStatusEnergy = true;
+        wwaData.isVisibleStatusStrength = true;
+        wwaData.isVisibleStatusDefence = true;
+        wwaData.isVisibleStatusGold = true;
+        wwaData.gameOverPolicy = "default";
+        wwaData.bgmDelayDurationMs = 0;
+        return wwaData;
+    }
+    getMessageFromData() {
+        let str = "";
+        let i = 0;
+        for (i = 0; i < 1500; i++) {
+            if (this.compressedMapData[this.currentPos + i * 2] == 0 &&
+                this.compressedMapData[this.currentPos + i * 2 + 1] == 0) {
+                break;
+            }
+            str += String.fromCharCode((this.compressedMapData[this.currentPos + i * 2 + 1] << 8) +
+                this.compressedMapData[this.currentPos + i * 2]);
+        }
+        this.currentPos += i * 2 + 2;
+        return str;
+    }
+}

package/module/index.d.ts

@@ -0,0 +1,2 @@
+export { WWALoader } from "./core";
+export * from "./infra";

package/module/index.js

@@ -0,0 +1,2 @@
+export { WWALoader } from "./core";
+export * from "./infra";

package/module/infra/index.d.ts

@@ -0,0 +1,98 @@
+import { WWAData } from "@wwawing/common-interface";
+import { IEventEmitter } from "@wwawing/event-emitter";
+export declare class WWAConsts {
+    static ITEMBOX_SIZE: number;
+    static MAP_ATR_MAX: number;
+    static OBJ_ATR_MAX: number;
+    static OLD_MAP_ATR_MAX: number;
+    static OLD_OBJ_ATR_MAX: number;
+    static ATR_CROP1: number;
+    static ATR_CROP2: number;
+    static ATR_TYPE: number;
+    static ATR_JUMP_X: number;
+    static ATR_JUMP_Y: number;
+    static MAP_LOCALGATE: number;
+    static OBJECT_LOCALGATE: number;
+    static SYSTEM_MESSAGE_NUM: number;
+    static IMGPOS_DEFAULT_YESNO_X: number;
+    static IMGPOS_DEFAULT_YESNO_Y: number;
+    static IMGPOS_DEFAULT_PLAYER_X: number;
+    static IMGPOS_DEFAULT_PLAYER_Y: number;
+    static IMGPOS_DEFAULT_CLICKABLE_ITEM_SIGN_X: number;
+    static IMGPOS_DEFAULT_CLICKABLE_ITEM_SIGN_Y: number;
+    static IMGPOS_DEFAULT_STATUS_X: number;
+    static IMGPOS_DEFAULT_STATUS_Y: number;
+    static IMGRELPOS_ENERGY_ICON_X: number;
+    static IMGRELPOS_STRENGTH_ICON_X: number;
+    static IMGRELPOS_DEFENCE_ICON_X: number;
+    static IMGRELPOS_GOLD_ICON_X: number;
+    static IMGPOS_DEFAULT_WIDE_CELL_X: number;
+    static IMGPOS_DEFAULT_WIDE_CELL_Y: number;
+    static IMGPOS_DEFAULT_ITEMBOX_X: number;
+    static IMGPOS_DEFAULT_ITEMBOX_Y: number;
+    static IMGPOS_DEFAULT_FRAME_X: number;
+    static IMGPOS_DEFAULT_FRAME_Y: number;
+    static IMGPOS_DEFAULT_BATTLE_EFFECT_X: number;
+    static IMGPOS_DEFAULT_BATTLE_EFFECT_Y: number;
+    static DEFAULT_DISABLE_SAVE: boolean;
+    static DEFAULT_OLDMAP: boolean;
+    static DEFAULT_OBJECT_NO_COLLAPSE: boolean;
+    static DEFAULT_FRAME_COLOR_R: number;
+    static DEFAULT_FRAME_COLOR_G: number;
+    static DEFAULT_FRAME_COLOR_B: number;
+    static DEFAULT_FRAMEOUT_COLOR_R: number;
+    static DEFAULT_FRAMEOUT_COLOR_G: number;
+    static DEFAULT_FRAMEOUT_COLOR_B: number;
+    static DEFAULT_STR_COLOR_R: number;
+    static DEFAULT_STR_COLOR_G: number;
+    static DEFAULT_STR_COLOR_B: number;
+    static DEFAULT_STATUS_COLOR_R: number;
+    static DEFAULT_STATUS_COLOR_G: number;
+    static DEFAULT_STATUS_COLOR_B: number;
+    static DEFAULT_MOVES: number;
+    static DEFAULT_SPEED_INDEX: number;
+    static USER_VAR_NUM: number;
+}
+export declare class LoaderError implements Error {
+    name: string;
+    message: string;
+}
+export declare class LoaderProgress {
+    current: number;
+    total: number;
+    stage: LoadStage;
+}
+export declare enum PartsType {
+    MAP = 1,
+    OBJECT = 0
+}
+export declare enum LoadStage {
+    INIT = 0,
+    MAP_LOAD = 1,
+    OBJ_LOAD = 2,
+    MAP_ATTR = 3,
+    OBJ_ATTR = 4,
+    RAND_PARTS = 5,
+    MESSAGE = 6
+}
+export declare function createDefaultWWAData(): WWAData;
+export interface Progress {
+    current: number;
+    total: number;
+    stage: LoadStage;
+}
+export interface LoaderError {
+    name: string;
+    message: string;
+}
+export interface WWALoaderEventEmitter extends IEventEmitter {
+    dispatch(eventName: "mapData", data: WWAData): void;
+    dispatch(eventName: "progress", data: Progress): void;
+    dispatch(eventName: "error", data: LoaderError): void;
+    addListener(eventName: "mapData", callback: (data: WWAData) => any): (data: WWAData) => any;
+    addListener(eventName: "progress", callback: (data: Progress) => any): (data: Progress) => any;
+    addListener(eventName: "error", callback: (data: LoaderError) => any): (data: LoaderError) => any;
+    removeListener(eventName: "mapData", callback: (...arg: any[]) => any): void;
+    removeListener(eventName: "progress", callback: (...arg: any[]) => any): void;
+    removeListener(eventName: "error", callback: (...arg: any[]) => any): void;
+}