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

package/lib/wwa_message.d.ts

@@ -0,0 +1,241 @@
+import { WWA } from "./wwa_main";
+import { Coord, PartsType, MacroType, Position, Direction, PreprocessMacroType, ScoreOptions as ScoreOptions } from "./wwa_data";
+import { Monster } from "./wwa_monster";
+import { WWAData } from "./wwa_data";
+import { WWASave } from "./wwa_save";
+import { type TokenValues, type Descriminant } from "./wwa_expression";
+export type LazyEvaluateValue = () => number;
+export type MessageSegments = (string | LazyEvaluateValue)[];
+export declare class Page {
+    firstNode?: Node;
+    isLastPage?: boolean;
+    showChoice?: boolean;
+    isSystemMessage?: boolean;
+    scoreOptions?: ScoreOptions;
+    extraInfo?: {
+        partsId: number;
+        partsType: PartsType;
+        partsPosition: Coord;
+    };
+    constructor(firstNode?: Node, isLastPage?: boolean, showChoice?: boolean, isSystemMessage?: boolean, scoreOptions?: ScoreOptions, extraInfo?: {
+        partsId: number;
+        partsType: PartsType;
+        partsPosition: Coord;
+    });
+}
+export declare abstract class Node {
+    constructor();
+}
+export interface Branch {
+    descriminant?: Descriminant;
+    elseBranch?: {
+        type: "real" | "pesudo-else";
+    };
+    next?: Node;
+}
+export declare class Junction extends Node {
+    branches: Branch[];
+    constructor(branches?: Branch[]);
+    appendBranch(branch: Branch): void;
+    getLastUnconnectedBranch(): Branch | undefined;
+    evaluateAndGetNextNode(generateTokenValues: () => TokenValues): Node | undefined;
+    hasElseBranch(): boolean;
+}
+export declare class ParsedMessage extends Node {
+    macro?: Macro[];
+    next?: Node;
+    private messageSegments;
+    constructor(textOrMessageSegments: string | MessageSegments, macro?: Macro[], next?: Node);
+    isEmpty(): boolean;
+    generatePrintableMessage(): string;
+    appendMessage(message: string | MessageSegments, withNewLine?: boolean): void;
+    private parseMessage;
+}
+export declare function isEmptyMessageTree(node: Node | undefined): boolean;
+export declare function getLastMessage(node: undefined): undefined;
+export declare function getLastMessage(node: Node): Node;
+export declare function concatMessage(node1: Node | undefined, node2: Node | undefined): Node | undefined;
+export type MessageLineType = PreprocessMacroType | "text" | "normalMacro";
+export declare const messagLineIsText: (lineType: MessageLineType) => lineType is "text" | MacroType.SHOW_STR | MacroType.SHOW_STR2 | "normalMacro";
+export type MessageLine = ({
+    type: PreprocessMacroType;
+    text: string;
+    macro: Macro;
+} | {
+    type: "normalMacro";
+    text: string;
+    macro: Macro;
+} | {
+    type: "text";
+    text: string;
+    macro?: undefined;
+});
+export declare class Macro {
+    private _wwa;
+    private _triggerPartsID;
+    private _triggerPartsType;
+    private _triggerPartsPosition;
+    macroType: MacroType;
+    macroArgs: string[];
+    constructor(_wwa: WWA, _triggerPartsID: number, _triggerPartsType: number, _triggerPartsPosition: Coord, macroType: MacroType, macroArgs: string[]);
+    isJunction(): boolean;
+    execute(): {
+        isGameOver?: true;
+    };
+    private _concatEmptyArgs;
+    private _evaluateIntValue;
+    private _executeJumpGateMacro;
+    private _executeRecPositionMacro;
+    private _executeJumpRecPositionMacro;
+    private _executeConsoleLogMacro;
+    private _executeCopyHpToMacro;
+    private _executeCopyHpMaxToMacro;
+    private _executeCopyAtToMacro;
+    private _executeCopyDfToMacro;
+    private _parseStatusKind;
+    private _executeCopyMoneyToMacro;
+    private _executeSetHPMacro;
+    private _executeSetHpMaxMacro;
+    private _executeSetAtMacro;
+    private _executeSetDfMacro;
+    private _executeSetMoneyMacro;
+    private _executeSetStepCountMacro;
+    private _executeVarSetValMacro;
+    private _executeVarSetMacro;
+    private _executeVarAddMacro;
+    private _executeVarSubMacro;
+    private _executeVarMulMacro;
+    private _executeVarDivMacro;
+    private _executeVarModMacro;
+    private _executeVarSetRandMacro;
+    private _executeGameSpeedMacro;
+    private _executeLegacyIfMacro;
+    private _executeSetSpeedMacro;
+    private _executeCopyTimeToMacro;
+    private _executeHideStatusMacro;
+    private _executeVarMapMacro;
+    private _executeImgPlayerMacro;
+    private _executeImgYesNoMacro;
+    private _executeHPMaxMacro;
+    private _executeSaveMacro;
+    private _executeItemMacro;
+    private _executeDefaultMacro;
+    private _executeOldMapMacro;
+    private _executePartsMacro;
+    private _executeMoveMacro;
+    private _executeMapMacro;
+    private _executeDirMapMacro;
+    private _executeImgFrameMacro;
+    private _executeImgBomMacro;
+    private _executeDelPlayerMacro;
+    private _executeFaceMacro;
+    private _executeEffectMacro;
+    private _executeGameOverMacro;
+    private _executeImgClickMacro;
+    private _executeEffItemMacro;
+    private _executeStatusMacro;
+    private _executeColorMacro;
+    private _executeWaitMacro;
+    private _executeSoundMacro;
+    private _executeGamePadButtonMacro;
+    private _executeOldMoveMacro;
+    private _executeNoGameOverMacro;
+    private _executeSetMacro;
+    private _executeDelayBgmMacro;
+    private _executeSysMsgMacro;
+    private resolveSystemMessageKeyFromMacroArg;
+}
+export declare function parseMacro(wwa: WWA, partsID: number, partsType: PartsType, position: Coord, macroStr: string): Macro;
+export declare class TextWindow {
+    protected _wwa: WWA;
+    protected _coord: Coord;
+    protected _width: number;
+    protected _height: number;
+    protected _isVisible: boolean;
+    protected _parentElement: HTMLElement;
+    protected _element: HTMLElement;
+    constructor(_wwa: WWA, _coord: Coord, _width: number, _height: number, _isVisible: boolean, _parentElement: HTMLElement, zIndex: number);
+    update(a?: any): void;
+    show(): void;
+    hide(): void;
+    isVisible(): boolean;
+    protected get windowName(): string;
+}
+export declare class MonsterWindow extends TextWindow {
+    protected _cgFileName: string;
+    protected _monsterBox: HTMLDivElement;
+    protected _energyBox: HTMLDivElement;
+    protected _strengthBox: HTMLDivElement;
+    protected _defenceBox: HTMLDivElement;
+    constructor(wwa: WWA, coord: Coord, width: number, height: number, isVisible: boolean, parentElement: HTMLElement, _cgFileName: string);
+    update(monster?: Monster): void;
+    protected get windowName(): string;
+}
+export declare class ScoreWindow extends TextWindow {
+    protected static WINDOW_NAME: string;
+    constructor(wwa: WWA, coord: Coord, isVisible: boolean, parentElement: HTMLElement);
+    update(score?: number): void;
+    protected get windowName(): string;
+}
+export declare enum Positioning {
+    TOP = 0,
+    CENTER = 1,
+    BOTTOM = 2,
+    SCORE = 3
+}
+export declare class MessageWindow {
+    private _wwa;
+    private _x;
+    private _y;
+    private _width;
+    private _height;
+    private _message;
+    private _cgFileName;
+    private _isVisible;
+    private _isYesno;
+    private _isSave;
+    private _isItemMenu;
+    private _isInputDisable;
+    private _element;
+    private _msgWrapperElement;
+    private _dummyElement;
+    private _saveElement;
+    private _ynWrapperElement;
+    private _divYesElement;
+    private _divNoElement;
+    private _parentElement;
+    private _wwaSave;
+    private _save_select_id;
+    private _save_counter;
+    private _save_close;
+    constructor(wwa: WWA, x: number, y: number, width: number, height: number, cgFileName: string, isVisible: boolean, isYesno: boolean, isItemMenu: boolean, parentElement: HTMLElement);
+    setPosition(x: number, y: number, width: number, height: number): void;
+    setPositionByPlayerPosition(existsFaces: boolean, existsScoreWindow: boolean, displayCenter: boolean, playerPos: Position, cameraPos: Position): void;
+    setPositionEasy(pos: Positioning): void;
+    setMessage(message: string): void;
+    clear(): void;
+    setYesNoChoice(isYesNo: boolean): boolean;
+    isYesNoChoice(): boolean;
+    isSaveChoice(): boolean;
+    setItemMenuChoice(isItemMenu: boolean): boolean;
+    isItemMenuChoice(): boolean;
+    setInputDisable(): void;
+    isInputDisable(): boolean;
+    show(): void;
+    hide(): void;
+    isVisible(): boolean;
+    private isWideChar;
+    private createClassicTextElement;
+    update(): void;
+    setWWASave(wwaSave: WWASave): void;
+    createSaveDom(): void;
+    deleteSaveDom(): void;
+    setSaveID(save_select_id: number): void;
+    save(gameCvs: HTMLCanvasElement, _quickSaveData: WWAData): boolean;
+    load(): WWAData;
+    saveUpdate(): void;
+    isSaveClose(): boolean;
+    private cursor_wait;
+    saveControll(moveDir: Direction): void;
+    protected get windowName(): string;
+}

package/lib/wwa_monster.d.ts

@@ -0,0 +1,19 @@
+import { Coord, Status } from "./wwa_data";
+export declare class Monster {
+    private _partsID;
+    private _position;
+    private _imgCoord;
+    private _status;
+    private _message;
+    private _item;
+    private _battleEndCallback;
+    constructor(_partsID: number, _position: Coord, _imgCoord: Coord, _status: Status, _message: string, _item: number, _battleEndCallback: () => void);
+    get partsID(): number;
+    get position(): Coord;
+    get imgCoord(): Coord;
+    get status(): Status;
+    get message(): string;
+    get item(): number;
+    damage(amount: number): void;
+    battleEndProcess(): void;
+}

package/lib/wwa_motion.d.ts

@@ -0,0 +1,29 @@
+import { WWA } from "./wwa_main";
+import { Direction as Dir, Position, Coord, Direction } from "./wwa_data";
+import { Player } from "./wwa_parts_player";
+export declare class ObjectMovingData {
+    private _player;
+    private _objectID;
+    private _srcPos;
+    private _destPos;
+    private _dir;
+    private _currentPos;
+    constructor(_player: Player, _objectID: number, _srcPos: Position, _destPos: Position, _dir: Dir);
+    update(): Position;
+    get isAchievedDestination(): boolean;
+    get currentPosition(): Position;
+    get beforePosition(): Position;
+    get destination(): Position;
+    get objID(): number;
+}
+export declare class ObjectMovingDataManager {
+    private _wwa;
+    private _player;
+    private _queue;
+    constructor(_wwa: WWA, _player: Player);
+    add(objectID: number, srcPos: Position, destPos: Position, dir: Direction): void;
+    update(): ObjectMovingData[];
+    clear(): void;
+    get objectMovingData(): ObjectMovingData[];
+    getOffsetByBeforePartsCoord(coord: Coord): Coord;
+}

package/lib/wwa_parts_player.d.ts

@@ -0,0 +1,169 @@
+import { WWA } from "./wwa_main";
+import { Position, Direction, Status, EquipmentStatus, PartsType, Coord } from "./wwa_data";
+import { Camera } from "./wwa_camera";
+import { Monster } from "./wwa_monster";
+export declare class Parts {
+    protected _position: Position;
+    protected _wwa: WWA;
+    getPosition(): Position;
+    constructor(pos: Position);
+}
+export declare class PartsObject extends Parts {
+    constructor(pos: Position);
+}
+export declare class PartsMap extends Parts {
+    constructor(pos: Position);
+}
+export declare enum PlayerState {
+    CONTROLLABLE = 0,
+    MOVING = 1,
+    CAMERA_MOVING = 2,
+    MESSAGE_WAITING = 3,
+    LOCALGATE_JUMPED = 4,
+    BATTLE = 5,
+    ESTIMATE_WINDOW_WAITING = 6,
+    PASSWORD_WINDOW_WAITING = 7,
+    LOCALGATE_JUMPED_WITH_MESSAGE = 8
+}
+export declare class Player extends PartsObject {
+    protected _status: Status;
+    protected _equipStatus: EquipmentStatus;
+    protected _energyMax: number;
+    protected _dir: Direction;
+    protected _jumpWaitFramesRemain: number;
+    protected _camera: Camera;
+    protected _state: PlayerState;
+    protected _isPartsEventExecuted: boolean;
+    protected _samePosLastExecutedMapID: number;
+    protected _samePosLastExecutedObjID: number;
+    protected _executedObjPartsID_onSamePosition: number;
+    protected _isMovingImage: boolean;
+    protected _partsAppeared: boolean;
+    protected _energyValueElement: HTMLElement;
+    protected _strengthValueElement: HTMLElement;
+    protected _defenceValueElement: HTMLElement;
+    protected _goldValueElement: HTMLElement;
+    protected _itemBox: number[];
+    protected _itemBoxElement: HTMLDivElement[];
+    protected _itemUsingEvent: EventListener[];
+    protected _readyToUseItemPos: number;
+    protected _isReadyToUseItem: boolean;
+    protected _battleFrameCounter: number;
+    protected _isPlayerTurn: boolean;
+    protected _battleTurnNum: number;
+    protected _enemy: Monster;
+    protected _moves: number;
+    protected _frameCount: number;
+    protected _moveMacroWaitingRemainMoves: number;
+    protected _moveObjectAutoExecTimer: number;
+    protected _afterMoveMacroFlag: boolean;
+    protected _isClickableItemGot: boolean;
+    protected _isPreparedForLookingAround: boolean;
+    protected _lookingAroundTimer: number;
+    protected _speedIndex: number;
+    protected _messageDelayFrameCount: number;
+    move(): void;
+    controll(moveDir: Direction): void;
+    setDir(newDir: Direction): void;
+    canMoveTo(pos: Position): boolean;
+    isMoving(): boolean;
+    private _isOnCameraMovingPosition;
+    private _isOnCameraStopPosition;
+    isControllable(): boolean;
+    getCopyOfItemBox(): number[];
+    getDir(): Direction;
+    isMovingImage(): boolean;
+    toggleMovingImage(): void;
+    getEnergyMax(): number;
+    isJumped(): boolean;
+    setMessageWaiting(): void;
+    isWaitingMessage(): boolean;
+    isDelayFrame(): boolean;
+    updateDelayFrame(): void;
+    setDelayFrame(): void;
+    clearMessageWaiting(): void;
+    setEstimateWindowWating(): void;
+    isWatingEstimateWindow(): boolean;
+    clearEstimateWindowWaiting(): void;
+    setPasswordWindowWating(): void;
+    isWaitingPasswordWindow(): boolean;
+    clearPasswordWindowWaiting(): void;
+    isPartsEventExecuted(): boolean;
+    resetEventExecutionInfo(): void;
+    getLastExecPartsIDOnSamePosition(type: PartsType): number;
+    setLastExecInfoOnSamePosition(type: PartsType, id: number): void;
+    processAfterJump(): void;
+    jumpTo(pos: Position): boolean;
+    systemJumpTo(pos: Position): void;
+    addStatusAll(s: Status): Status;
+    setEnergyMax(em: number): number;
+    setEnergy(e: number): number;
+    damage(amount: number): void;
+    setStrength(s: number): number;
+    setDefence(d: number): number;
+    setGold(g: number): number;
+    getStatus(): Status;
+    getStatusWithoutEquipments(): Status;
+    getStatusOfEquipments(): EquipmentStatus;
+    updateStatusValueBox(): void;
+    readonly itemTransitioningClassName = "item-transitioning";
+    readonly overwittenItemClassName = "item-overwritten";
+    readonly overwittenItemSelector: string;
+    readonly itemEffectStartTimers: (number | undefined)[];
+    updateItemBox(animationOption?: {
+        insertPos: number;
+        itemScreenPixelCoord: Coord;
+        itemBoxScreenPixelCoord: Coord;
+        itemBoxBackgroundImageCoord: Coord;
+        overwrittenObjectId?: number;
+    }): void;
+    private startItemEffect;
+    private disposeItemEffect;
+    isDead(): boolean;
+    addItem(objID: number, itemPos?: number, isOverwrite?: boolean, animationOption?: {
+        screenPixelCoord: Coord;
+        itemBoxBackgroundImageCoord: Coord;
+    }): void;
+    private _forceSetItemBox;
+    private _getBlankItemPos;
+    private _updateEquipmentStatus;
+    hasItem(partsID: number): boolean;
+    canUseItem(itemPos: number): boolean;
+    useItem(): number;
+    canHaveMoreItems(): boolean;
+    removeItemByItemPosition(itemPos: number): void;
+    removeItemByPartsID(partsID: number): void;
+    clearItemBox(): void;
+    hasGold(gold: number): boolean;
+    payGold(gold: number): void;
+    earnGold(gold: number): void;
+    setPartsAppearedFlag(): void;
+    clearPartsAppearedFlag(): void;
+    isPartsAppearedTime(): boolean;
+    startBattleWith(enemy: Monster): void;
+    isFighting(): boolean;
+    isTurn(): boolean;
+    getTurnNum(): number;
+    isBattleStartFrame(): boolean;
+    fight(): void;
+    readyToUseItem(itemPos: number): void;
+    isReadyToUseItem(): boolean;
+    getDrawingCenterPosition(): Coord;
+    mainFrameCount(): void;
+    getFrameCount(): number;
+    setFrameCount(count: number): number;
+    getMoveCount(): number;
+    setMoveCount(count: number): number;
+    isMoveObjectAutoExecTime(): boolean;
+    setMoveMacroWaiting(moveNum: number): void;
+    resetMoveObjectAutoExecTimer(): void;
+    decrementMoveObjectAutoExecTimer(): number;
+    isWaitingMoveMacro(): boolean;
+    decrementLookingAroundTimer(): number;
+    isLookingAround(): boolean;
+    getSpeedIndex(): number;
+    speedUp(): number;
+    speedDown(): number;
+    setSpeedIndex(speedIndex: number): number;
+    constructor(wwa: WWA, pos: Position, camera: Camera, status: Status, em: number, moves: number, gameSpeedIndex: number);
+}

package/lib/wwa_password_window.d.ts

@@ -0,0 +1,28 @@
+import { WWA } from "./wwa_main";
+export declare enum Mode {
+    SAVE = 0,
+    LOAD = 1
+}
+export declare class PasswordWindow {
+    private _wwa;
+    private _parent;
+    private _isDisallowLoadOldSave;
+    private readonly COPIED_MESSAGE_DISPLAY_MS;
+    private _element;
+    private _okButtonElement;
+    private _cancelButtonElement;
+    private _copyButtonElement;
+    private _descriptionElement;
+    private _passwordBoxElement;
+    private _buttonWrapperElement;
+    private _isVisible;
+    private _mode;
+    constructor(_wwa: WWA, _parent: HTMLDivElement, _isDisallowLoadOldSave: boolean);
+    get mode(): Mode;
+    set mode(mode: Mode);
+    get password(): string;
+    set password(password: string);
+    show(mode?: Mode): void;
+    hide(): void;
+    update(): void;
+}

package/lib/wwa_play_time.d.ts

@@ -0,0 +1,8 @@
+export declare class PlayTimeCalculator {
+    private lastCalculatedTimeUnixMs;
+    private lastCalculatedPlayTimeMs;
+    constructor(baseTimeMs?: number);
+    calculateTimeMs(): number;
+    calculatePlayTimeFormat(): string;
+    static formatPlayTimeText(timeSec: number): string;
+}

package/lib/wwa_save/WWACompress.d.ts

@@ -0,0 +1,36 @@
+import { WWAData } from "../wwa_data";
+import { WWADataWithWorldNameStatus } from "./common";
+export declare class FirstChangedMapUint8Table {
+    map: Uint8Array;
+    mapObject: Uint8Array;
+}
+export default class WWACompress {
+    private static _usingByteFlag;
+    private static MIN_LOOP_COUNT;
+    private static _restartData;
+    private static _mapByteLength;
+    private static _firstRandomMapObjectUtf8Table;
+    static compress(wwaData: WWAData): object;
+    private static compressObject;
+    private static compressUserVars;
+    private static compressMapAllObject;
+    private static indexListCompress;
+    private static idSort;
+    private static getCompressArray;
+    private static getDecompressArray;
+    static decompress(saveObject: object): WWADataWithWorldNameStatus;
+    private static decompressObject;
+    private static decompressUserVars;
+    private static generateEmptyUserVars;
+    private static decompressAllMapObject;
+    static setRestartData(restartData: WWAData, firstFrameData: WWAData): void;
+    private static getChangedUint8Array;
+    static getStartWWAData(resumeSaveTextData: string): WWAData;
+    static usingByte(_usingByteFlag: any): void;
+}
+export declare class WWACompressIndexTable {
+    id: number;
+    index: number;
+    count: number;
+    constructor(id: number, index: number);
+}

package/lib/wwa_save/WWASave.d.ts

@@ -0,0 +1,27 @@
+import { WWAData, ChoiceCallInfo } from "../wwa_data";
+import { WWA } from "../wwa_main";
+import { Player } from "../wwa_parts_player";
+import WWASaveDataList from "./WWASaveDataList";
+import { OnCheckLoadingSaveDataFunction, OnCompleteLoadingSaveDataFunction } from "./common";
+export default class WWASave {
+    static checkOriginalMapString: string;
+    static worldName: string;
+    static mapDataRevisionKey: string;
+    private _wwaDBSaveList;
+    private _wwaLogSaveList;
+    list: WWASaveDataList;
+    constructor(wwa: WWA, worldName: string, worldPassNumber: number, onCheckLoadingSaveData: OnCheckLoadingSaveDataFunction, onCompleteLoadingSaveData: OnCompleteLoadingSaveDataFunction);
+    resumeStart(): void;
+    isAutoSaveFrame(player: Player): boolean;
+    autoSave(gameCvs: HTMLCanvasElement, _quickSaveData: WWAData): void;
+    selectDBSaveDataList(): void;
+    selectLogSaveDataList(): void;
+    save(gameCvs: HTMLCanvasElement, _quickSaveData: WWAData, id: number): boolean;
+    load(id: number): WWAData;
+    hasSaveData(): boolean;
+    setAutoSaveInterval(autoInterval: number): void;
+    getFirstSaveChoiceCallInfo(forcePassword: boolean): ChoiceCallInfo;
+    getSecondSaveChoiceCallInfo(usePassword: boolean): ChoiceCallInfo;
+    gameStart(wwaData: WWAData, player: Player): void;
+    quickSaveButtonUpdate(wwaData: WWAData): void;
+}

package/lib/wwa_save/WWASaveData.d.ts

@@ -0,0 +1,20 @@
+import { WWAData } from "../wwa_data";
+import WWASaveDataList from "./WWASaveDataList";
+export default class WWASaveData {
+    protected _parent: WWASaveDataList;
+    protected _id: number;
+    flag: boolean;
+    date: Date;
+    cvs: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    protected quickSaveData: WWAData;
+    _statusEnergy: number;
+    constructor(id: number, parent: WWASaveDataList);
+    showQickLoad(): void;
+    save(gameCvs: HTMLCanvasElement, _quickSaveData: WWAData): boolean;
+    getStatusEnergy(): number;
+    load(): WWAData;
+    saveDataSet(src: string, quickSaveData: WWAData, date: Date): void;
+    getDateText(): string;
+    isLastSaveData(): boolean;
+}

package/lib/wwa_save/WWASaveDataDB.d.ts

@@ -0,0 +1,5 @@
+import { WWAData } from "../wwa_data";
+import WWASaveData from "./WWASaveData";
+export default class WWASaveDataDB extends WWASaveData {
+    save(gameCvs: HTMLCanvasElement, _quickSaveData: WWAData): boolean;
+}

package/lib/wwa_save/WWASaveDataDBList.d.ts

@@ -0,0 +1,31 @@
+import { WWAData } from "../wwa_data";
+import WWASaveDataList from "./WWASaveDataList";
+import { OnCheckLoadingSaveDataFunction, OnCompleteLoadingSaveDataFunction } from "./common";
+type WWASaveDataItem = {
+    url?: string;
+    id: number;
+    hash: string;
+    image: string;
+    data: object;
+    date: Date;
+    worldName: string | undefined;
+    mapDataRevisionKey: string | undefined;
+};
+export default class WWASaveDataDBList extends WWASaveDataList {
+    private selectDatas;
+    private IDBTransaction;
+    private onCheckLoadingSaveData;
+    private onCompleteLoadingSaveData;
+    private static doNotAnything;
+    protected keyPath: string | string[];
+    constructor(onCheckLoadingSaveData: OnCheckLoadingSaveDataFunction, onCompleteLoadingSaveData: OnCompleteLoadingSaveDataFunction, prototype?: WWASaveDataDBList);
+    private indexDBOpen;
+    private createDataBase;
+    private getObjectStore;
+    protected makeSaveDataItem(saveID: number, gameCvs: HTMLCanvasElement, compressedData: object, date: Date): WWASaveDataItem;
+    protected getSaveDataResult(store: IDBObjectStore, onsuccess: (result: WWASaveDataItem[]) => void): void;
+    dbUpdateSaveData(saveID: number, gameCvs: HTMLCanvasElement, _quickSaveData: WWAData, date: Date): void;
+    dbDeleteSaveData(saveIDs: number[]): void;
+    private selectSaveData;
+}
+export {};

package/lib/wwa_save/WWASaveDataList.d.ts

@@ -0,0 +1,6 @@
+import WWASaveData from "./WWASaveData";
+export default class WWASaveDataList extends Array<WWASaveData> {
+    constructor();
+    hasSaveData(): boolean;
+    getLastSaveData(): WWASaveData;
+}

package/lib/wwa_save/WWASaveDataLog.d.ts

@@ -0,0 +1,3 @@
+import WWASaveData from "./WWASaveData";
+export default class WWASaveDataLog extends WWASaveData {
+}

package/lib/wwa_save/WWASaveDataLogList.d.ts

@@ -0,0 +1,14 @@
+import { WWAData } from "../wwa_data";
+import WWASaveDataList from "./WWASaveDataList";
+import { Player } from "../wwa_parts_player";
+export default class WWASaveDataLogList extends WWASaveDataList {
+    private _saveNo;
+    private _lastAutoSaveMove;
+    private _autoInterval;
+    constructor();
+    resumeStart(): void;
+    setPlayer(player: Player): void;
+    isAutoSaveFrame(player: Player): boolean;
+    autoSave(gameCvs: HTMLCanvasElement, _quickSaveData: WWAData): void;
+    setAutoSaveInterval(autoInterval: number): void;
+}

package/lib/wwa_save/common/definitions.d.ts

@@ -0,0 +1,11 @@
+import { WWAData } from "../../wwa_data";
+export declare enum LoadErrorCode {
+    UNMATCHED_WORLD_NAME = "UNMATCHED_WORLD_NAME",
+    UNMATCHED_WORLD_PASS_NUMBER = "UNMATCHED_WORLD_PASS_NUMBER",
+    DISALLOW_OLD_REVISION_WORLD_SAVE_DATA = "DISALLOW_OLD_REVISION_WORLD_SAVE_DATA"
+}
+export type OnCompleteLoadingSaveDataFunction = (hasFailedLoadingSaveData: LoadErrorCode[]) => void;
+export type OnCheckLoadingSaveDataFunction = (saveDataWorldName: string | undefined, saveDataHash: string, mapDataRevisionKey: string | undefined) => LoadErrorCode | null;
+export type WWADataWithWorldNameStatus = [WWAData, {
+    isWorldNameEmpty: boolean;
+}];

package/lib/wwa_save/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./mapDataRevisionKey";
+export * from "./definitions";

package/lib/wwa_save/common/mapDataRevisionKey.d.ts

@@ -0,0 +1 @@
+export declare function generateMapDataRevisionKey(worldName: string, worldPassNumber: number): string;

package/lib/wwa_save/index.d.ts

@@ -0,0 +1,6 @@
+import WWACompress from './WWACompress';
+import WWASave from './WWASave';
+import WWASaveData from './WWASaveData';
+export * from "./common";
+export * as Migrators from "./migrators";
+export { WWACompress, WWASave, WWASaveData, };

package/lib/wwa_save/migrators/index.d.ts

@@ -0,0 +1,2 @@
+import { WWAData } from "../../wwa_data";
+export declare const applyAllMigrators: (wwaData: WWAData) => WWAData;