@wwawing/engine 3.13.0-unstable.based-on.3.12.11.p.11 → 4.0.0

package/lib/wwa_data/options.d.ts

@@ -0,0 +1,2 @@
+import { DataWWAOptions } from "./typedef";
+export declare function makeDefaultWWAOptions(): DataWWAOptions;

package/lib/wwa_data/typedef.d.ts

@@ -0,0 +1,20 @@
+export interface DataWWAOptions {
+    mapdata: string;
+    urlGateEnable?: boolean;
+    titleImg?: string;
+    audioDir?: string;
+    classicModeEnable?: boolean;
+    itemEffectEnable?: boolean;
+    useGoToWwa?: boolean;
+    lookingAround?: boolean;
+    autoSave?: boolean;
+    disallowLoadOldSave?: boolean;
+    resumeSaveData?: string;
+    varDumpElm?: HTMLElement;
+    userVarNamesFile?: string;
+    displayUserVars?: boolean;
+    virtualPadEnable?: boolean;
+    virtualPadViewportFitEnable?: boolean;
+    virtualPadControllerElm?: HTMLElement;
+    userDefinedScriptsFile?: string;
+}

package/lib/wwa_data.d.ts

@@ -1,6 +1,6 @@
+import { type WWAData } from "@wwawing/common-interface";
 import { WWA } from "./wwa_main";
 import { Camera } from "./wwa_camera";
-import { type WWAData } from "@wwawing/common-interface";
 import type { JsonResponseErrorKind } from "./json_api_client";
 export { type WWAData };
 export declare class EquipmentStatus {
@@ -19,7 +19,7 @@ export declare class Status extends EquipmentStatus {
     plus(s: EquipmentStatus): Status;
     minus(s: EquipmentStatus): Status;
     equals(e: Status): boolean;
-    calculateScore(scoreOption: ScoreOptions): number;
+    calculateScore(scoreOption: ScoreOption): number;
     clone(): Status;
     constructor(e: number, s: number, d: number, g: number);
 }
@@ -564,7 +564,7 @@ export declare enum IDTable {
 }
 export type StatusSolutionKind = "all" | "bare" | "equipment";
 export type UserVarNameListRequestErrorKind = JsonResponseErrorKind | "notObject" | "noFileSpecified";
-export interface ScoreOptions {
+export interface ScoreOption {
     rates: ScoreRates;
 }
 export interface ScoreRates {

package/lib/wwa_expression/typedef.d.ts

@@ -46,10 +46,10 @@ export interface TokenValues {
     moveCount: number;
     playTime: number;
     userVars: (number | string | boolean)[];
-    partsPosition: Coord;
+    partsPosition?: Coord;
     playerCoord: Coord;
-    partsId: number;
-    partsType: PartsType;
+    partsId?: number;
+    partsType?: PartsType;
     map: number[][];
     mapObject: number[][];
     itemBox: number[];

package/lib/wwa_expression2/eval.d.ts

@@ -1,36 +1,48 @@
-import { BattleEstimateParameters } from "../wwa_data";
+import { BattleEstimateParameters, Coord, PartsType } from "../wwa_data";
 import { WWA } from "../wwa_main";
 import * as Wwa from "./wwa";
+import { PageAdditionalItem } from "./typedef";
 export declare class EvalCalcWwaNodeGenerator {
     wwa: WWA;
     loop_limit: number;
     state: {
+        readonly triggerParts?: {
+            id?: number;
+            type?: PartsType;
+            position?: Coord;
+        };
         readonly earnedItem?: {
             partsId?: number;
-            itemPos?: number;
+            itemPos1To12?: number;
         };
         readonly battleDamageCalculation?: {
             aborted?: boolean;
             estimatingParams?: BattleEstimateParameters;
         };
+        messagePageAdditionalQueue: PageAdditionalItem[];
     };
     constructor(wwa: WWA);
-    setEarnedItem(partsId: number, itemPos: number): void;
+    setTriggerParts(partsId: number, partsType: PartsType, position: Coord): void;
+    clearTemporaryState(): void;
+    setEarnedItem(partsId: number, itemPos1To12: number): void;
     clearEarnedItem(): void;
     setBattleDamageCalculationMode(estimatingParams: BattleEstimateParameters): void;
     clearBattleDamageCalculationMode(): void;
-    evalWwaNodes(nodes: Wwa.WWANode[]): any[];
+    evalWwaNodes(nodes: Wwa.WWANode[]): any;
     evalWwaNode(node: Wwa.WWANode): any;
+    addPageAdditionalItem(item: PageAdditionalItem): void;
+    pickPageAdditionalQueue(): PageAdditionalItem[];
     updateLoopLimit(limit: number): void;
 }
 export declare class EvalCalcWwaNode {
     generator: EvalCalcWwaNodeGenerator;
     private for_id;
     constructor(generator: EvalCalcWwaNodeGenerator);
-    private evalWwaNodes;
+    evalWwaNodes(nodes: Wwa.WWANode[]): any;
     evalWwaNode(node: Wwa.WWANode): any;
-    callDefinedFunction(node: Wwa.CallDefinedFunction): void;
-    updateExpression(node: Wwa.UpdateExpression): void;
+    private wrapCallFunction;
+    callDefinedFunction(node: Wwa.CallDefinedFunction): any;
+    updateExpression(node: Wwa.UpdateExpression): any;
     logicalExpression(node: Wwa.LogicalExpression): any;
     convertTemplateLiteral(node: Wwa.TemplateLiteral): string;
     contunueStatment(node: Wwa.Continue): void;
@@ -41,18 +53,20 @@ export declare class EvalCalcWwaNode {
     evalAnyFunction(node: Wwa.AnyFunction): any;
     private resolveSystemMessageKeyFromMacroArg;
     partsAssignment(node: Wwa.PartsAssignment): void;
-    blockStatement(node: Wwa.BlockStatement): void;
-    ifStatement(node: Wwa.IfStatement): number;
+    private resolveParts;
+    blockStatement(node: Wwa.BlockStatement): any;
+    ifStatement(node: Wwa.IfStatement): any;
     convertConditionalExpression(node: Wwa.ConditionalExpression): any;
-    itemAssignment(node: Wwa.ItemAssignment): number;
-    evalMessage(node: Wwa.Msg): number;
-    evalJumpgate(node: Wwa.Jumpgate): void;
+    convertLoopPointerExpression(node: Wwa.LoopPointerAssignment): number;
+    itemAssignment(node: Wwa.ItemAssignment): any;
+    evalMessage(node: Wwa.Msg): any;
+    evalJumpgate(node: Wwa.Jumpgate): any;
     evalRandom(node: Wwa.Random): any;
-    evalSetSpecialParameter(node: Wwa.SpecialParameterAssignment): number;
-    evalSetUserVariable(node: Wwa.UserVariableAssignment): number;
+    evalSetSpecialParameter(node: Wwa.SpecialParameterAssignment): any;
+    evalSetUserVariable(node: Wwa.UserVariableAssignment): any;
     evalUnaryOperation(node: Wwa.UnaryOperation): any;
     evalBinaryOperation(node: Wwa.BinaryOperation): any;
-    evalSymbol(node: Wwa.Symbol): number;
+    evalSymbol(node: Wwa.Symbol): number | number[];
     evalArray1D(node: Wwa.Array1D): any;
     evalArray2D(node: Wwa.Array2D): number;
     evalNumber(node: Wwa.Literal): string | number;

package/lib/wwa_expression2/typedef.d.ts

@@ -0,0 +1,9 @@
+import { Face } from "../wwa_data";
+interface PageAdditionalFaceItem {
+    type: "face";
+    data: {
+        face: Face;
+    };
+}
+export type PageAdditionalItem = PageAdditionalFaceItem;
+export {};

package/lib/wwa_expression2/wwa.d.ts

@@ -20,9 +20,15 @@ export interface UserVariableAssignment {
     value: Calcurable;
     operator?: "=" | "+=" | "-=" | "*=" | "/=";
 }
+export interface LoopPointerAssignment {
+    type: "LoopPointerAssignment";
+    index: Calcurable;
+    value: Calcurable;
+    operator?: "=" | "+=" | "-=" | "*=" | "/=";
+}
 export interface SpecialParameterAssignment {
     type: "SpecialParameterAssignment";
-    kind: "X" | "Y" | "PX" | "PY" | "HP" | "HPMAX" | "AT" | "DF" | "GD" | "STEP" | "TIME" | "PDIR" | "i" | "j" | "k" | "LOOPLIMIT" | "ITEM_ID" | "ITEM_POS";
+    kind: "PX" | "PY" | "HP" | "HPMAX" | "AT" | "DF" | "GD" | "STEP" | "TIME" | "PDIR" | "i" | "j" | "k" | "LOOPLIMIT" | "ITEM_ID" | "ITEM_POS";
     value: Calcurable;
     operator?: "=" | "+=" | "-=" | "*=" | "/=";
 }
@@ -39,11 +45,11 @@ export interface BinaryOperation {
 }
 export interface Symbol {
     type: "Symbol";
-    name: "ITEM" | "m" | "o" | "v" | "X" | "Y" | "PX" | "PY" | "HP" | "HPMAX" | "AT" | "AT_TOTAL" | "DF" | "DF_TOTAL" | "GD" | "STEP" | "TIME" | "PDIR" | "i" | "j" | "k" | "LOOPLIMIT" | "ITEM_ID" | "ITEM_POS" | "ENEMY_HP" | "ENEMY_AT" | "ENEMY_DF" | "ENEMY_GD";
+    name: "ITEM" | "m" | "o" | "v" | "X" | "Y" | "ID" | "TYPE" | "PX" | "PY" | "CX" | "CY" | "HP" | "HPMAX" | "AT" | "AT_TOTAL" | "DF" | "DF_TOTAL" | "GD" | "STEP" | "TIME" | "PDIR" | "i" | "j" | "k" | "LOOPLIMIT" | "ITEM_ID" | "ITEM_POS" | "ENEMY_HP" | "ENEMY_AT" | "ENEMY_DF" | "ENEMY_GD" | "LP";
 }
 export interface Array1D {
     type: "Array1D";
-    name: "ITEM" | "m" | "o" | "v";
+    name: "ITEM" | "m" | "o" | "v" | "LP";
     index0: Calcurable;
 }
 export interface Array2D {
@@ -141,4 +147,4 @@ export interface ConditionalExpression {
     test: WWANode;
     alternate: WWANode;
 }
-export type WWANode = PartsAssignment | ItemAssignment | UserVariableAssignment | SpecialParameterAssignment | UnaryOperation | BinaryOperation | Array1D | Array2D | Literal | Symbol | Random | Jumpgate | Msg | IfStatement | BlockStatement | AnyFunction | DefinedFunction | CallDefinedFunction | ForStatement | AnyFunction | Break | Continue | Return | UpdateExpression | LogicalExpression | TemplateLiteral | TemplateElement | ConditionalExpression;
+export type WWANode = PartsAssignment | ItemAssignment | UserVariableAssignment | SpecialParameterAssignment | UnaryOperation | BinaryOperation | Array1D | Array2D | Literal | Symbol | Random | Jumpgate | Msg | IfStatement | BlockStatement | AnyFunction | DefinedFunction | CallDefinedFunction | ForStatement | AnyFunction | Break | Continue | Return | UpdateExpression | LogicalExpression | TemplateLiteral | TemplateElement | ConditionalExpression | LoopPointerAssignment;

package/lib/wwa_macro.d.ts

@@ -0,0 +1,76 @@
+import { WWA } from "./wwa_main";
+import { MacroType, TriggerParts } from "./wwa_data";
+export declare class Macro {
+    private _wwa;
+    private _triggerParts;
+    macroType: MacroType;
+    macroArgs: string[];
+    constructor(_wwa: WWA, _triggerParts: TriggerParts, 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, triggerParts: TriggerParts, macroStr: string): Macro;

package/lib/wwa_main.d.ts

@@ -1,11 +1,14 @@
 import { SystemMessage } from "@wwawing/common-interface";
-import { Coord, Position, LoaderProgress, LoadStage, YesNoState, Status, Face, Direction, SidebarButton, SpeedChange, PartsType, AppearanceTriggerType, EquipmentStatus, ChangeStyleType, MacroStatusIndex, UserDevice, MacroImgFrameIndex, StatusKind, StatusSolutionKind, ScoreOptions, TriggerParts, type BattleTurnResult, BattleEstimateParameters, BattleDamageDirection } from "./wwa_data";
-import { MessageWindow, Page } from "./wwa_message";
+import { WWAData as Data, Coord, Position, LoaderProgress, LoadStage, YesNoState, Status, Face, Direction, SidebarButton, SpeedChange, PartsType, AppearanceTriggerType, EquipmentStatus, ChangeStyleType, MacroStatusIndex, UserDevice, MacroImgFrameIndex, StatusKind, StatusSolutionKind, ScoreOption, TriggerParts, type BattleTurnResult, BattleEstimateParameters, BattleDamageDirection } from "./wwa_data";
+import { MessageRequestPage } from "./wwa_message";
+import { MessageWindow } from "./wwa_window";
 import { ItemMenu } from "./wwa_item_menu";
 import { WWACompress } from "./wwa_save";
 import { IEventEmitter } from "@wwawing/event-emitter";
 import * as ExpressionParser from "./wwa_expression";
 import { WWANode } from "./wwa_expression2/wwa";
+import { DataWWAOptions } from "./wwa_data/typedef";
+import { PageAdditionalItem } from "./wwa_expression2/typedef";
 export declare function getProgress(current: number, total: number, stage: LoadStage): LoaderProgress;
 interface PartsAppearance {
     pos: Coord;
@@ -81,6 +84,7 @@ export declare class WWA {
     private _useLookingAround;
     private _isDisallowLoadOldSave;
     private _userVar;
+    private _pageExecuting;
     private _inlineUserVarViewer;
     private _userVarNameList;
     private _userVarNameListRequestError;
@@ -107,8 +111,8 @@ export declare class WWA {
     private _dumpElement;
     private evalCalcWwaNodeGenerator;
     private userDefinedFunctions;
-    constructor(mapFileName: string, urlgateEnabled: boolean, titleImgName: string, classicModeEnabled: boolean, itemEffectEnabled: boolean, useGoToWWA: boolean, audioDirectory: string, disallowLoadOldSave: boolean, dumpElm: HTMLElement, userVarNamesFile: string | null, canDisplayUserVars: boolean, enableVirtualPad?: boolean, virtualpadControllerElm?: HTMLElement);
-    setEvalCalcWwaNodeEarnedItem(itemObjectId: number, itemPos: number): void;
+    constructor(options?: DataWWAOptions);
+    setEvalCalcWwaNodeEarnedItem(itemObjectId: number, itemPos1To12: number): void;
     clearEvalCalcWwaNodeEarnedItem(): void;
     callGetItemUserDefineFunction(): void;
     callGetItemFullUserDefineFunction(): void;
@@ -117,6 +121,7 @@ export declare class WWA {
     callUserDefinedBattleDamageFunction(damageDirection: BattleDamageDirection, estimatingParams?: BattleEstimateParameters): BattleTurnResult | undefined;
     private getUserDefinedDamageFunctionNode;
     callMoveUserDefineFunction(): void;
+    callCameraMoveUserDefineFunction(): void;
     getUserScript(functionName: string): WWANode | null;
     private setUsertScript;
     private convertWwaNodes;
@@ -134,7 +139,7 @@ export declare class WWA {
     openGameWindow(): void;
     mainCaller: () => void;
     soundCheckCaller: () => void;
-    onselectitem(itemPos: number): boolean;
+    onselectitem(itemPos1To12: number): boolean;
     onselectbutton(button: SidebarButton, forcePassword?: boolean, forceGoToWWA?: boolean): void;
     onpasswordloadcalled(): void;
     onpasswordsavecalled(): void;
@@ -143,8 +148,6 @@ export declare class WWA {
     onchangespeed(type: SpeedChange): void;
     isBattleSpeedIndexForQuickBattle(battleSpeedIndex: number): boolean;
     private _checkTurnKeyPressed;
-    private _executeNode;
-    private _executeNodes;
     private _main;
     vibration(isStrong: boolean): void;
     private _drawAll;
@@ -169,7 +172,9 @@ export declare class WWA {
     getObjectCropYById(id: number): number;
     getMessageById(messageID: number): string;
     getSystemMessageById(messageID: number): string;
+    getMapInfo(partsID: number): number[];
     checkMap(pos?: Coord): boolean;
+    getObjectInfo(partsID: number): number[];
     checkObject(pos?: Coord): void;
     private _execMapStreetEvent;
     private _shouldTreatWillMessageDisplay;
@@ -188,20 +193,24 @@ export declare class WWA {
     private _execObjectLocalGateEvent;
     private _execObjectUrlGateEvent;
     private _execObjectScoreEvent;
-    updateScore(scoreOption?: ScoreOptions): void;
+    updateScore(scoreOption?: ScoreOption): void;
     private _execChoiceWindowObjectSellEvent;
     private _execChoiceWindowRunningEvent;
     private _dispatchWindowClosedTimeRequests;
     private _dispatchPlayerAndObjectsStopTimeRequests;
     private _clearAllRequests;
-    reserveMessageDisplayWhenShouldOpen(message: string): void;
-    generatePageAndReserveExecution(message: string, showChoice: boolean, isSystemMessage: boolean, partsID?: number, partsType?: PartsType, partsPosition?: Coord, scoreOption?: ScoreOptions | undefined): void;
-    generatePagesByRawMessage(message: string, partsId: number, partsType: PartsType, partsPosition: Coord, isSystemMessage: boolean, showChoice: boolean, scoreOption: ScoreOptions): Page[];
-    private parseMessageLines;
-    private createNewNode;
-    private processConditionalExecuteMacroLine;
-    private connectOrMergeToPreviousNode;
-    private connectToFinalNode;
+    reserveMessageDisplayWhenShouldOpen(messageRequest: MessageRequestPage): void;
+    handleMsgFunction(messageRequest: MessageRequestPage): void;
+    registerSystemMessagePage(message: string, showChoice?: boolean): void;
+    registerSystemMessagePageByKey(systemMessageKey: SystemMessage.Key): void;
+    private _createSimpleMessage;
+    registerPageByMessage(message: string, { showChoice, isSystemMessage, triggerParts, scoreOption, additionalItems, }?: {
+        showChoice?: boolean;
+        isSystemMessage?: boolean;
+        triggerParts?: TriggerParts;
+        scoreOption?: ScoreOption;
+        additionalItems?: PageAdditionalItem[];
+    }): void;
     appearParts({ pos, triggerType, triggerPartsId }: PartsAppearance): void;
     reserveAppearPartsInNextFrame(pos: Coord, triggerType: AppearanceTriggerType, triggerPartsId?: number): void;
     reserveJumpInNextFrame(position: Position): void;
@@ -330,14 +339,13 @@ export declare class WWA {
     setUserValDiv(x: number, y: number): void;
     setUserValMod(x: number, y: number): void;
     setUserValRandNum(x: number, num: number, bias: number): void;
-    private _generateShowStrString;
     speedChangeJudge(speedChangeFlag: boolean): void;
     execSetMacro(macroStr: string, option: {
         triggerParts: TriggerParts;
     }): {
         isGameOver?: true;
     };
-    generateTokenValues(triggerParts: TriggerParts): ExpressionParser.TokenValues;
+    generateTokenValues(triggerParts?: TriggerParts): ExpressionParser.TokenValues;
     userVarUserIf(_triggerPartsPosition: Coord, args: string[]): void;
     private compareUserVar;
     setPlayerSpeedIndex(speedIndex: number): void;
@@ -371,7 +379,9 @@ export declare class WWA {
         userVars: (string | number | boolean)[];
         playerCoord: Coord;
         playerDirection: Direction;
+        cameraCoord: Coord;
         itemBox: number[];
+        wwaData: Data;
     };
     private _debugEvalString;
     private _execEvalString;

package/lib/wwa_message/_internal/index.d.ts

@@ -0,0 +1,32 @@
+import { MacroType, type TriggerParts } from "../../wwa_data";
+import type { Macro } from "../../wwa_macro";
+import { Node, Page, MessageLineType, Junction, MessageLine, MessageSegments, PageGeneratingOption } from "../data";
+import * as ExpressionParser from "../../wwa_expression";
+export declare function normalizeMessage(message: string): string;
+export declare function splitMessageByTags(message: string): {
+    pageContents: string[];
+    script?: string;
+};
+export declare function createPage({ content, script, generatingOption, pageType, parseMacro, evalScript, generateTokenValuesCallback, }: {
+    content: string;
+    script?: string;
+    generatingOption: PageGeneratingOption;
+    pageType: "first" | "last" | "other";
+    parseMacro: (macroStr: string) => Macro;
+    evalScript: (script: string, triggerParts?: TriggerParts) => void;
+    generateTokenValuesCallback: (triggerParts: TriggerParts) => ExpressionParser.TokenValues;
+}): Page;
+export declare const messageLineIsText: (lineType: MessageLineType) => lineType is "text" | MacroType.SHOW_STR | MacroType.SHOW_STR2 | "normalMacro";
+export declare function parseMessageLines(pageContent: string, parseMacro: (macroStr: string) => Macro): MessageLine[];
+export declare function createNewNode(currentLine: MessageLine, shouldCreateParsedMessage: boolean, generateTokenValues: (triggerParts?: TriggerParts) => ExpressionParser.TokenValues, evalScript: (script: string, triggerParts?: TriggerParts) => void, option: {
+    triggerParts: TriggerParts;
+}): Node | undefined;
+export declare function processConditionalExecuteMacroLine(newNode: Node, currentLine: MessageLine, parentJunction: Junction | undefined, junctionNodeStack: Junction[]): Junction | undefined;
+export declare function connectOrMergeToPreviousNode(currentLine: MessageLine, previousLineType: MessageLineType, nodeByPrevLine: Node | undefined, newNode: Node | undefined, parentJunction: Junction, endIfTargetJunction: Junction | undefined, generateTokenValues: (triggerParts: TriggerParts) => ExpressionParser.TokenValues, option: {
+    triggerParts: TriggerParts;
+}): void;
+export declare function connectToFinalNode(firstNode: Node, targetNode: Node): void;
+export declare function generateShowStrString(macroArgs: string[], generateTokenValues: (triggerParts?: TriggerParts) => ExpressionParser.TokenValues, option: {
+    triggerParts: TriggerParts;
+    version: 1 | 2;
+}): MessageSegments;

package/lib/wwa_message/data/index.d.ts

@@ -0,0 +1,18 @@
+import { PreprocessMacroType } from "../../wwa_data";
+import { Macro } from "../../wwa_macro";
+export { Node, Branch, Junction, LazyEvaluateValue, ParsedMessage, MessageSegments } from "./node";
+export { Page, PageGeneratingOption } from "./page";
+export type MessageLineType = PreprocessMacroType | "text" | "normalMacro";
+export type MessageLine = {
+    type: PreprocessMacroType;
+    text: string;
+    macro: Macro;
+} | {
+    type: "normalMacro";
+    text: string;
+    macro: Macro;
+} | {
+    type: "text";
+    text: string;
+    macro?: undefined;
+};

package/lib/wwa_message/data/node.d.ts

@@ -0,0 +1,46 @@
+import type { TriggerParts } from "../../wwa_data";
+import { type TokenValues, type Descriminant } from "../../wwa_expression";
+import { Macro } from "../../wwa_macro";
+export declare abstract class Node {
+    protected generateTokenValues: (triggerParts?: TriggerParts) => TokenValues;
+    constructor(generateTokenValues: (triggerParts?: TriggerParts) => TokenValues);
+    abstract execute(triggerParts?: TriggerParts): ParsedMessage[];
+    static executeNodes(firstNode: Node | undefined, triggerParts?: TriggerParts): {
+        isError: false;
+        messages: ParsedMessage[];
+    } | {
+        isError: true;
+    };
+}
+export interface Branch {
+    descriminant?: Descriminant;
+    elseBranch?: {
+        type: "real" | "pesudo-else";
+    };
+    next?: Node;
+}
+export declare class Junction extends Node {
+    branches: Branch[];
+    constructor(branches: Branch[], generateTokenValues: (triggerParts?: TriggerParts) => TokenValues);
+    appendBranch(branch: Branch): void;
+    getLastUnconnectedBranch(): Branch | undefined;
+    evaluateAndGetNextNode(triggerParts?: TriggerParts): Node | undefined;
+    hasElseBranch(): boolean;
+    execute(triggerParts?: TriggerParts): ParsedMessage[];
+}
+export type LazyEvaluateValue = () => number | string | boolean;
+export type MessageSegments = (string | LazyEvaluateValue)[];
+export declare class ParsedMessage extends Node {
+    private evalScript;
+    macro?: Macro[];
+    next?: Node;
+    script?: string;
+    private messageSegments;
+    constructor(textOrMessageSegments: string | MessageSegments, generateTokenValues: (triggerParts?: TriggerParts) => TokenValues, evalScript: (script: string, triggerParts?: TriggerParts) => void, macro?: Macro[], next?: Node, script?: string);
+    isEmpty(): boolean;
+    generatePrintableMessage(): string;
+    appendMessage(message: string | MessageSegments, withNewLine?: boolean): void;
+    static createEmptyMessage(generateTokenValues: (triggerParts?: TriggerParts) => TokenValues, evalScript: (script: string, triggerParts?: TriggerParts) => void, script?: string): ParsedMessage;
+    private parseMessage;
+    execute(triggerParts?: TriggerParts): ParsedMessage[];
+}

package/lib/wwa_message/data/page.d.ts

@@ -0,0 +1,13 @@
+import type { ScoreOption, TriggerParts } from "../../wwa_data";
+import { PageAdditionalItem } from "../../wwa_expression2/typedef";
+import { Node } from "./node";
+export interface Page {
+    firstNode?: Node;
+    isLastPage: boolean;
+    triggerParts: TriggerParts;
+    isSystemMessage: boolean;
+    showChoice: boolean;
+    scoreOption?: ScoreOption;
+    additionalItems?: PageAdditionalItem[];
+}
+export type PageGeneratingOption = Pick<Page, "triggerParts" | "isSystemMessage" | "showChoice" | "scoreOption" | "additionalItems">;

package/lib/wwa_message/index.d.ts

@@ -0,0 +1,10 @@
+import { TriggerParts } from "../wwa_data";
+import { Node, Page, PageGeneratingOption } from "./data";
+import * as ExpressionParser from "../wwa_expression";
+import { Macro } from "../wwa_macro";
+export * from "./data";
+export * from "./typedef";
+export declare function generatePagesByRawMessage(message: string, generatingOption: PageGeneratingOption, parseMacro: (macroStr: string) => Macro, evalScript: (script: string, triggerParts?: TriggerParts) => void, generateTokenValuesCallback: (triggerParts: TriggerParts) => ExpressionParser.TokenValues): Page[];
+export declare function isEmptyMessageTree(node: Node | undefined): boolean;
+export declare function getLastMessage(node: undefined): undefined;
+export declare function getLastMessage(node: Node): Node;

package/lib/wwa_message/typedef.d.ts

@@ -0,0 +1,5 @@
+import { PageAdditionalItem } from "../wwa_expression2/typedef";
+export interface MessageRequestPage {
+    message: string;
+    additionalItems: PageAdditionalItem[];
+}

package/lib/wwa_parts_player.d.ts

@@ -46,7 +46,7 @@ export declare class Player extends PartsObject {
     protected _itemBox: number[];
     protected _itemBoxElement: HTMLDivElement[];
     protected _itemUsingEvent: EventListener[];
-    protected _readyToUseItemPos: number;
+    protected _readyToUseItemPos1To12: number;
     protected _isReadyToUseItem: boolean;
     protected _battleFrameCounter: number;
     protected _isPlayerTurn: boolean;
@@ -150,7 +150,7 @@ export declare class Player extends PartsObject {
     calcBattleResultForEnemyTurn(enemyStatus: Status, playerStatus: Status, estimating?: boolean): BattleTurnResult;
     private _calcDamageDefault;
     fight(): void;
-    readyToUseItem(itemPos: number): void;
+    readyToUseItem(itemPos1To12: number): void;
     isReadyToUseItem(): boolean;
     getDrawingCenterPosition(): Coord;
     mainFrameCount(): void;

package/lib/wwa_window.d.ts

@@ -0,0 +1,97 @@
+import { WWA } from "./wwa_main";
+import { WWAData, Coord, Position, Direction } from "./wwa_data";
+import { Monster } from "./wwa_monster";
+import { WWASave } from "./wwa_save";
+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;
+}