qpremake 1.5.1

package/lib/_queenSystem/queenSystem.d.ts

@@ -0,0 +1,127 @@
+import _node from "../types/abstract/generics/node";
+import _tree from "../types/abstract/generics/tree";
+import zoneHandler from "./handler/zoneHandler";
+import actionRegistry, { actionName } from "../data/actionRegistry";
+import { Action, Action_class } from "./handler/actionGenrator";
+import type error from "../types/errors/error";
+import { Setting } from "../types/abstract/gameComponents/settings";
+import cardHandler from "./handler/cardHandler";
+import registryHandler from "./handler/registryHandler";
+import modHandler from "./handler/modHandler";
+import Localizer from "./handler/localizationHandler";
+import { operatorRegistry } from "../data/operatorRegistry";
+import { playerTypeID, zoneRegistry } from "../data/zoneRegistry";
+import Card from "../types/abstract/gameComponents/card";
+import Zone from "../types/abstract/gameComponents/zone";
+import { inputData, player_stat, TurnPhase, dry_card, dry_effect, dry_position, dry_zone, dry_effectSubType, logInfoHasResponse, logInfoNormal, logInfoResolve, logInfo, dry_system, inputType, inputData_card, inputData_pos, inputDataSpecific, inputData_zone, inputData_effect, inputData_subtype } from "../data/systemRegistry";
+import { Player_specific, Positionable } from "../types/misc";
+import { inputRequester } from "./handler/actionInputGenerator";
+import { qpRenderer } from "./renderer/rendererInterface";
+import { SerializedSystem } from "../types/abstract/serializedGameComponents/Gamestate";
+import { parseMode } from "../types/abstract/parser";
+type doGetNewNode = boolean;
+type completed = boolean;
+type cardID = string;
+type effectID = string;
+declare class queenSystem {
+    renderer: qpRenderer;
+    turnAction?: Action;
+    turnCount: number;
+    waveCount: number;
+    zoneHandler: zoneHandler;
+    cardHandler: cardHandler;
+    registryFile: registryHandler;
+    modHandler: modHandler;
+    localizer: Localizer;
+    setting: Setting;
+    player_stat: player_stat[];
+    private processStack;
+    private suspendID;
+    private suspensionReason;
+    private curr_input_obj;
+    get isSuspended(): boolean;
+    fullLog: logInfo[];
+    phaseIdx: TurnPhase;
+    actionTree: _tree<Action<"a_turn_end">>;
+    get rootID(): number;
+    getRootAction(): Action_class<[], boolean, {
+        doIncreaseTurnCount: boolean;
+    }>;
+    get threatLevel(): number[];
+    set threatLevel(val: number | number[]);
+    get maxThreatLevel(): number[];
+    constructor(s: Setting, renderer: qpRenderer);
+    addDeck(loadCardsInfo: player_stat["loadCardsInfo"], merge?: boolean): void;
+    addPlayers(type: keyof typeof playerTypeID, operatorID: operatorRegistry, loadCardsInfo?: player_stat["loadCardsInfo"], heart?: number, maxHeart?: number): void;
+    load(gamestate?: SerializedSystem): Promise<void>;
+    loadGamestate(gamestate: SerializedSystem): void;
+    restartTurn(a?: Action): void;
+    resolveError(a: error): void;
+    ___testAction(id: actionRegistry): boolean;
+    private actionSwitch_resolve;
+    start(): void;
+    processTurn(startNode?: _node): completed;
+    processTurn(turnActionFromPlayer?: Action): completed;
+    process(n: _node): doGetNewNode;
+    suspend(nid: number): void;
+    private verifyInput;
+    private inputHandler;
+    getAllInputs<T extends inputType>(t: T): inputDataSpecific<T>[] | undefined;
+    getAllInputs<T extends inputType>(t: T, force: true): inputDataSpecific<T>[];
+    generateSignature(a: inputData | undefined): string;
+    continue(input?: inputData): boolean;
+    getActivatedEffectIDs(): effectID[];
+    getActivatedCardIDs(): cardID[];
+    getResolvedActions(): Action[];
+    getCardWithID(cid: string): dry_card | undefined;
+    getCardWithDataID(cid: string): dry_card[];
+    getZoneWithID(zid: number): dry_zone | undefined;
+    getZoneOf(obj: Positionable): dry_zone | undefined;
+    get zoneArr(): readonly Zone<undefined, undefined, undefined, undefined>[];
+    get resolutionLog(): logInfoResolve[];
+    get chainLog(): logInfoHasResponse[];
+    get triggerLog(): logInfoHasResponse[];
+    get completionLog(): logInfoNormal[];
+    hasActionCompleted(a: Action, startSearchingIndex?: number): boolean;
+    /**
+     * Finds a chain of action A -> resolved to B -> resolved to C -> ...
+     * @param typeArr : action types to search
+     * @returns  Action[] if success, unefined if not
+     *
+     *
+     * Search is first comes first serve, B is the first in the resoution log of A that has the wanted type (id 1 in the arr)
+     */
+    findSpecificChainOfAction_resolve<T extends actionName[]>(typeArr: T): Action[] | undefined;
+    /**
+     * Parses the whole log though the condition funciton, tally and returns the result
+     * @param condition a function that returns a thing parsable to a number
+     * @param stopEarlyCount a count that if reached, will return early
+     * @returns total count
+     *
+     *
+     */
+    count(condition: (log: logInfo) => number | boolean | undefined, stopEarlyCount?: number): number;
+    getAllZonesOfPlayer(pid: number): Record<number, dry_zone[]>;
+    getPIDof(c: Positionable): number;
+    is(c: Positionable, type: zoneRegistry): boolean;
+    get isInTriggerPhase(): boolean;
+    get isInChainPhase(): boolean;
+    requestInput_zone_default(c: Positionable | Player_specific, zType: zoneRegistry, fz?: (s: dry_system, z: dry_zone) => boolean): inputRequester<inputType.zone, [inputData_zone], [inputData_zone], inputData_zone, inputData_zone, []>;
+    requestInput_card_default(c: Positionable, zType: zoneRegistry, fz?: (s: dry_system, z: dry_zone) => boolean, fc?: (s: dry_system, c: dry_card, z: dry_zone) => boolean): inputRequester<inputType, [inputData_zone, inputData_card], [inputData_zone, inputData_card], inputData_card, inputData_zone, [inputData_card]>;
+    requestInput_effect_default(c: Positionable, zType: zoneRegistry, getRealEffects: boolean, getStatusEffects: boolean, fz?: (s: dry_system, z: dry_zone) => boolean, fc?: (s: dry_system, c: dry_card, z: dry_zone) => boolean, feff?: (s: dry_system, eff: dry_effect, c: dry_card, z: dry_zone) => boolean): inputRequester<inputType, [inputData_zone, inputData_card, inputData_effect], [inputData_zone, inputData_card, inputData_effect], inputData_effect, inputData_zone, [inputData_card, inputData_effect]>;
+    requestInput_effectSubtype_default(c: Positionable, zType: zoneRegistry, getRealEffects: boolean, getStatusEffects: boolean, fz?: (s: dry_system, z: dry_zone) => boolean, fc?: (s: dry_system, c: dry_card, z: dry_zone) => boolean, feff?: (s: dry_system, eff: dry_effect, c: dry_card, z: dry_zone) => boolean, fst?: (s: dry_system, st: dry_effectSubType, eff: dry_effect, c: dry_card, z: dry_zone) => boolean): inputRequester<inputType, [inputData_zone, inputData_card, inputData_effect, inputData_subtype], [inputData_zone, inputData_card, inputData_effect, inputData_subtype], inputData_subtype, inputData_zone, [inputData_card, inputData_effect, inputData_subtype]>;
+    requestInput_pos_default(c: Positionable, zType: zoneRegistry, getFreeOnly: boolean, fz?: (s: dry_system, z: dry_zone) => boolean, fpos?: (s: dry_system, p: dry_position, z: dry_zone) => boolean): inputRequester<inputType, [inputData_zone, inputData_pos], [inputData_zone, inputData_pos], inputData_pos, inputData_zone, [inputData_pos]>;
+    getWouldBeAttackTarget(a: Action<"a_attack"> | Action<"a_deal_damage_ahead">): [] | [Zone<undefined, undefined, undefined, undefined>, Card[]];
+    private posCheck;
+    isNotActionArr<T>(gen: T | Action[]): gen is T;
+    forEach: zoneHandler["forEach"];
+    map: zoneHandler["map"];
+    filter: zoneHandler["filter"];
+    readonly NULLPOS: dry_position;
+    readonly NULLCARD: dry_card;
+    isPlayAction(a: Action): a is Action<"a_pos_change"> | Action<"a_pos_change_force">;
+    toSerialized(): SerializedSystem;
+    toLocalized(mode?: parseMode): import("../types/abstract/serializedGameComponents/Localized").LocalizedSystem | undefined;
+}
+export default queenSystem;
+export { logInfo };