qpremake 1.5.1

package/lib/_queenSystem/handler/actionInputRequesterGenerator.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zoneRegistry_1 = require("../../data/zoneRegistry");
+const actionInputGenerator_1 = require("./actionInputGenerator");
+const systemRegistry_1 = require("../../data/systemRegistry");
+const e_status_1 = require("../../specificEffects/e_status");
+class regen_cards {
+    constructor(s, cards) {
+        this.s = s;
+        this.cards = cards;
+    }
+    ofArchtype(p) {
+        this.cards = this.cards.filter(c => c.is(p));
+        return this;
+    }
+    ofSameArchtype(c1) {
+        this.cards = this.cards.filter(c => c.is(c1.extensionArr));
+        return this;
+    }
+    ofSameField(c1) {
+        this.cards = this.cards.filter(c => c.pos.zoneID === c1.pos.zoneID);
+        return this;
+    }
+    hasStatus() {
+        this.cards = this.cards.filter(c => c.hasStatusEffect);
+        return this;
+    }
+    hasAutomate() {
+        this.cards = this.cards.filter(c => c.hasStatusEffect && c.statusEffects.some(e => e instanceof e_status_1.e_automate_base));
+        return this;
+    }
+    isExposed() {
+        this.cards = this.cards.filter(c => c.___zone.isExposed(c));
+        return this;
+    }
+    isCoverred() {
+        this.cards = this.cards.filter(c => !c.___zone.isExposed(c));
+        return this;
+    }
+    isBack() {
+        this.cards = this.cards.filter(c => {
+            //a card is in the back if its back pos is out of bounds
+            const back = c.___zone.getBackPos(c);
+            return Utils.isPositionOutOfBounds(back.flat(), c.___zone.shape);
+        });
+        return this;
+    }
+    isFront() {
+        this.cards = this.cards.filter(c => {
+            //a card is in the front if its front pos is out of bounds
+            const front = c.___zone.getFrontPos(c);
+            return Utils.isPositionOutOfBounds(front.flat(), c.___zone.shape);
+        });
+        return this;
+    }
+    ofLevel(l) {
+        this.cards = this.cards.filter(c => c.level === l);
+        return this;
+    }
+    ofAtLeastLevel(l) {
+        this.cards = this.cards.filter(c => c.level <= l);
+        return this;
+    }
+    ofDataID(s) {
+        this.cards = this.cards.filter(c => c.dataID === s);
+        return this;
+    }
+    ofSameDataID(c_) {
+        this.cards = this.cards.filter(c => c.dataID === c_.dataID);
+        return this;
+    }
+    pos() {
+        return new regen_pos(this.s, this.cards.map(c => {
+            const p1 = c.pos;
+            p1.___zone = c.___zone;
+            delete c.___zone;
+            return p1;
+        }));
+    }
+    zones() {
+        return new regen_zone(this.s, this.cards.map(c => {
+            const z1 = c.___zone;
+            delete c.___zone;
+            return z1;
+        }));
+    }
+    filter(f) {
+        if (f)
+            this.cards.filter(f);
+        return this;
+    }
+    once(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.c);
+        return new actionInputGenerator_1.inputRequester(systemRegistry_1.inputType.card, this.cards.map(c => {
+            delete c.___zone;
+            return actionInputGenerator_1.inputFormRegistry.card(this.s, c);
+        }));
+    }
+    many(l, e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.c);
+        return new actionInputGenerator_1.inputRequester_multiple(l, systemRegistry_1.inputType.card, this.cards.map(c => {
+            delete c.___zone;
+            return actionInputGenerator_1.inputFormRegistry.card(this.s, c);
+        }));
+    }
+    // all(e? : Effect<any>){
+    //     if(e) this.filter(e.addedInputConditionMap.c);
+    //     return new inputRequester_multiple(
+    //         this.cards.length,
+    //         inputType.card,
+    //         this.cards.map(c => {
+    //             delete (c as any).___zone
+    //             return inputFormRegistry.card(this.s, c)
+    //         })
+    //     )
+    // }
+    clean(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.c);
+        return this.cards.map(p => {
+            delete p.___zone;
+            return p;
+        });
+    }
+}
+class regen_pos {
+    constructor(s, pos) {
+        this.s = s;
+        this.pos = pos;
+    }
+    isEmpty() {
+        this.pos = this.pos.filter(p => !p.___zone.isOccupied(p));
+        return this;
+    }
+    isOccupied() {
+        this.pos = this.pos.filter(p => p.___zone.isOccupied(p));
+        return this;
+    }
+    isExposed() {
+        this.pos = this.pos.filter(p => p.___zone.isExposed({ pos: p }));
+        return this;
+    }
+    isCoverred() {
+        this.pos = this.pos.filter(p => !p.___zone.isExposed({ pos: p }));
+        return this;
+    }
+    isBack() {
+        this.pos = this.pos.filter(p => {
+            //a card is in the back if its back pos is out of bounds
+            const back = p.___zone.getBackPos({ pos: p });
+            return Utils.isPositionOutOfBounds(back.flat(), p.___zone.shape);
+        });
+        return this;
+    }
+    isFront() {
+        this.pos = this.pos.filter(p => {
+            //a card is in the front if its front pos is out of bounds
+            const front = p.___zone.getFrontPos({ pos: p });
+            return Utils.isPositionOutOfBounds(front.flat(), p.___zone.shape);
+        });
+        return this;
+    }
+    cards() {
+        return new regen_cards(this.s, this.pos.map(p => {
+            const card = p.___zone.cardArr[Utils.positionToIndex(p.flat(), p.___zone.shape)];
+            if (!card) {
+                delete p.___zone;
+                return;
+            }
+            ;
+            const c1 = card;
+            c1.___zone = p.___zone;
+            delete p.___zone;
+            return c1;
+        }).filter(p => p !== undefined));
+    }
+    zones() {
+        return new regen_zone(this.s, this.pos.map(p => {
+            const z1 = p.___zone;
+            delete p.___zone;
+            return z1;
+        }));
+    }
+    filter(f) {
+        if (f)
+            this.pos.filter(f);
+        return this;
+    }
+    once(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.p);
+        return new actionInputGenerator_1.inputRequester(systemRegistry_1.inputType.position, this.pos.map(p => {
+            delete p.___zone;
+            return actionInputGenerator_1.inputFormRegistry.pos(this.s, p);
+        }));
+    }
+    many(l, e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.p);
+        return new actionInputGenerator_1.inputRequester_multiple(l, systemRegistry_1.inputType.position, this.pos.map(p => {
+            delete p.___zone;
+            return actionInputGenerator_1.inputFormRegistry.pos(this.s, p);
+        }));
+    }
+    // all(e? : Effect<any>){
+    //     if(e) this.filter(e.addedInputConditionMap.p);
+    //     return new inputRequester_multiple(
+    //         this.pos.length,
+    //         inputType.position,
+    //         this.pos.map(p => {
+    //             delete (p as any).___zone
+    //             return inputFormRegistry.pos(this.s, p)
+    //         })
+    //     )
+    // }
+    clean(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.p);
+        return this.pos.map(p => {
+            delete p.___zone;
+            return p;
+        });
+    }
+}
+class regen_zone {
+    constructor(s, zones) {
+        this.s = s;
+        this.zones = zones;
+    }
+    cards() {
+        return new regen_cards(this.s, this.zones.flatMap(z => {
+            const carr = z.cardArr_filtered;
+            return carr.map(c => {
+                const c1 = c;
+                c1.___zone = z;
+                return c1;
+            });
+        }));
+    }
+    pos() {
+        return new regen_pos(this.s, this.zones.flatMap(z => {
+            const pos = z.getAllPos();
+            return pos.map(p => {
+                const p1 = p;
+                p1.___zone = z;
+                return p1;
+            });
+        }));
+    }
+    ofSamePlayer(pstat) {
+        this.zones = pstat ? this.zones.filter(z => z.playerIndex === pstat.playerIndex) : [];
+        return this;
+    }
+    ofSamePlayerType(pstat) {
+        this.zones = pstat ? this.zones.filter(z => z.playerType === pstat.playerType) : [];
+        return this;
+    }
+    filter(f) {
+        if (f)
+            this.zones = this.zones.filter(f);
+        return this;
+    }
+    once(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.z);
+        return new actionInputGenerator_1.inputRequester(systemRegistry_1.inputType.zone, this.zones.map(z => actionInputGenerator_1.inputFormRegistry.zone(this.s, z)));
+    }
+    many(l, e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.z);
+        return new actionInputGenerator_1.inputRequester_multiple(l, systemRegistry_1.inputType.zone, this.zones.map(z => actionInputGenerator_1.inputFormRegistry.zone(this.s, z)));
+    }
+    // all(e? : Effect<any>){
+    //     if(e) this.filter(e.addedInputConditionMap.z);
+    //     return new inputRequester_multiple(
+    //         this.zones.length,
+    //         inputType.zone,
+    //         this.zones.map(z => inputFormRegistry.zone(this.s, z))
+    //     )
+    // }
+    clean(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.z);
+        return this.zones;
+    }
+}
+class regen_nums {
+    constructor(s, nums) {
+        this.s = s;
+        this.nums = nums;
+    }
+    filter(f) {
+        if (f)
+            this.nums = this.nums.filter(f);
+    }
+    once(e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.n);
+        return new actionInputGenerator_1.inputRequester(systemRegistry_1.inputType.number, this.nums.map(n => actionInputGenerator_1.inputFormRegistry.num(n)));
+    }
+    many(l, e) {
+        if (e)
+            this.filter(e.addedInputConditionMap.n);
+        return new actionInputGenerator_1.inputRequester_multiple(l, systemRegistry_1.inputType.number, this.nums.map(n => actionInputGenerator_1.inputFormRegistry.num(n)));
+    }
+}
+class inputRequesterGenerator {
+    //zones
+    field(s, c) {
+        return new regen_zone(s, s.filter(0, z => z.is(zoneRegistry_1.zoneRegistry.z_field)));
+    }
+    grave(s, c) {
+        return new regen_zone(s, s.filter(0, z => z.is(zoneRegistry_1.zoneRegistry.z_grave)));
+    }
+    deck(s, c) {
+        return new regen_zone(s, s.filter(0, z => z.is(zoneRegistry_1.zoneRegistry.z_deck)));
+    }
+    hand(s, c) {
+        return new regen_zone(s, s.filter(0, z => z.is(zoneRegistry_1.zoneRegistry.z_hand)));
+    }
+    specificType(s, c, zType) {
+        return new regen_zone(s, s.filter(0, z => z.is(zType)));
+    }
+    oppositeZoneTo(s, c) {
+        return new regen_zone(s, s.getZoneOf(c).getOppositeZone(this.field(s, c).clean()));
+    }
+    allZones(s, c) {
+        return new regen_zone(s, s.filter(0, () => true));
+    }
+    //misc
+    nums(s, ...nums) {
+        const merged = nums.reduce((prev, cur) => {
+            return [...prev, ...(typeof cur === "number" ? [cur] : cur)];
+        }, []);
+        return new regen_nums(s, merged);
+    }
+}
+const Request = new inputRequesterGenerator();
+exports.default = Request;

package/lib/_queenSystem/handler/cardHandler.d.ts

@@ -0,0 +1,20 @@
+import type registryHandler from "./registryHandler";
+import type { Setting } from "../../types/abstract/gameComponents/settings";
+import { cardData_unified, cardDataRegistry, effectData } from "../../data/cardRegistry";
+import type Card from "../../types/abstract/gameComponents/card";
+export default class cardHandler {
+    private cloader;
+    private effloader;
+    private subtypeloader;
+    private typeLoader;
+    private setting;
+    constructor(s: Setting, regs: registryHandler);
+    getCard(cid: keyof typeof cardDataRegistry, variantID?: string[]): Card;
+    getCard(cid: string, variantID?: string[]): Card | undefined;
+    getCard(cid: keyof typeof cardDataRegistry, variantID: string[], dataOnly: true): Omit<cardData_unified, "effects"> & {
+        effects: effectData[];
+    };
+    getCard(cid: string, variantID: string[], dataOnly: true): Omit<cardData_unified, "effects"> & {
+        effects: effectData[];
+    } | undefined;
+}

package/lib/_queenSystem/handler/cardHandler.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const subtypeRegistry_1 = __importDefault(require("../../data/subtypeRegistry"));
+const subtype_chained_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_chained"));
+const subtype_fieldLock_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_fieldLock"));
+const subtype_hardUnique_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_hardUnique"));
+const subtype_instant_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_instant"));
+const subtype_once_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_once"));
+const subtype_unique_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_unique"));
+const subtype_hand_or_fieldLock_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_hand_or_fieldLock"));
+const subtype_graveLock_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_graveLock"));
+const subtype_delayed_1 = __importDefault(require("../../types/effects/effectSubtypes/subtype_delayed"));
+const effectTypeRegistry_1 = __importDefault(require("../../data/effectTypeRegistry"));
+const effectType_1 = __importDefault(require("../../types/abstract/gameComponents/effectType"));
+const initEffect_1 = __importDefault(require("../../types/effects/effectTypes/initEffect"));
+const manualEffect_1 = __importDefault(require("../../types/effects/effectTypes/manualEffect"));
+const passiveEffect_1 = __importDefault(require("../../types/effects/effectTypes/passiveEffect"));
+const triggerEffect_1 = __importDefault(require("../../types/effects/effectTypes/triggerEffect"));
+const lockEffect_1 = __importDefault(require("../../types/effects/effectTypes/lockEffect"));
+const cardRegistry_1 = require("../../data/cardRegistry");
+class cardHandler {
+    constructor(s, regs) {
+        this.cloader = regs.cardLoader;
+        this.effloader = regs.effectLoader;
+        this.subtypeloader = regs.subTypeLoader;
+        this.typeLoader = regs.typeLoader;
+        this.setting = s;
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_chained], subtype_chained_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_fieldLock], subtype_fieldLock_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_hardUnique], subtype_hardUnique_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_instant], subtype_instant_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_once], subtype_once_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_unique], subtype_unique_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_handOrFieldLock], subtype_hand_or_fieldLock_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_graveLock], subtype_graveLock_1.default);
+        this.subtypeloader.load(subtypeRegistry_1.default[subtypeRegistry_1.default.e_st_delayed], subtype_delayed_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_none], effectType_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_counter], effectType_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_init], initEffect_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_manual], manualEffect_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_passive], passiveEffect_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_trigger], triggerEffect_1.default);
+        this.typeLoader.load(effectTypeRegistry_1.default[effectTypeRegistry_1.default.e_t_lock], lockEffect_1.default);
+        // this.rarityLoader.load(rarityRegistry[rarityRegistry.r_white], rarityDataRegistry.r_white)
+        // this.rarityLoader.load(rarityRegistry[rarityRegistry.r_green], rarityDataRegistry.r_green)
+        // this.rarityLoader.load(rarityRegistry[rarityRegistry.r_blue], rarityDataRegistry.r_blue)
+        // this.rarityLoader.load(rarityRegistry[rarityRegistry.r_red], rarityDataRegistry.r_red)
+        // this.rarityLoader.load(rarityRegistry[rarityRegistry.r_ability], rarityDataRegistry.r_ability)
+        // this.rarityLoader.load(rarityRegistry[rarityRegistry.r_algo], rarityDataRegistry.r_algo)
+        Object.entries(cardRegistry_1.cardDataRegistry).forEach(([key, val]) => {
+            this.cloader.load(key, Object.assign({ id: key }, val));
+        });
+    }
+    getCard(cid, variantID, dataOnly = false) {
+        return this.cloader.getCard(cid, this.setting, variantID, dataOnly);
+    }
+}
+exports.default = cardHandler;

package/lib/_queenSystem/handler/effectGenerator.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/_queenSystem/handler/effectGenerator.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**@deprecated */
+const systemRegistry_1 = require("../../data/systemRegistry");
+const effect_1 = __importDefault(require("../../types/abstract/gameComponents/effect"));
+class eff_gen {
+    constructor(input_f1, input_f2, activate_f) {
+        this.input_f2 = input_f2;
+        this.activate_f = activate_f;
+        this.revealKeys = [];
+        this.implyVar = [];
+        this.input_f1_info = {
+            init: input_f1,
+            chained: []
+        };
+    }
+    retarget(key, input_f1_new, input_f2_new, newActivate) {
+        switch (key) {
+            case "zone": {
+                this.input_f1_info.chained.push(input_f1_new);
+                this.input_f2 = input_f2_new;
+                this.activate_f = newActivate(this.activate_f);
+                return this;
+            }
+            case "card": {
+                const res = new eff_gen_cards(this.input_f1_info.init, input_f2_new, newActivate(this.activate_f));
+                res.revealKeys = this.revealKeys;
+                res.implyVar = this.implyVar;
+                res.input_f1_info.chained = this.input_f1_info.chained;
+                res.input_f1_info.chained.push(input_f1_new);
+                return res;
+            }
+            case "pos": {
+                const res = new eff_gen_pos(this.input_f1_info.init, input_f2_new, newActivate(this.activate_f));
+                res.revealKeys = this.revealKeys;
+                res.implyVar = this.implyVar;
+                res.input_f1_info.chained = this.input_f1_info.chained;
+                res.input_f1_info.chained.push(input_f1_new);
+                return res;
+            }
+        }
+        throw new Error();
+    }
+    ;
+    then(f) {
+        this.input_f1_info.chained.push(f);
+        return this;
+    }
+    shares(f) {
+        this.implyVar.push(f);
+        return this;
+    }
+    reveal(k) {
+        if (typeof k === "string")
+            this.revealKeys.push(k);
+        else
+            this.revealKeys.push(...k);
+        return this;
+    }
+    fin() {
+        const f1 = this.input_f1_info;
+        const f2 = this.input_f2;
+        const f3 = this.activate_f;
+        const implyVar = this.implyVar;
+        const revealKeys = this.revealKeys;
+        const type = this.checkInputType;
+        return class ExtendedEff extends effect_1.default {
+            createInputObj(c, s, a) {
+                let res = f1.init.bind(this)(c, s, a);
+                res = f1.chained.reduce((prev, cur) => cur.bind(this)(prev), res);
+                return f2.bind(this)(res);
+            }
+            activate_final(c, s, a, input) {
+                if (!input)
+                    return [];
+                const res = input.next();
+                const ret = res.flatMap(i => i.type === type ? f3.bind(this)(i) : []);
+                implyVar.forEach(f => {
+                    const [key, val] = f.bind(this)(ret, c, s, a);
+                    c.addShareMemory(this, key, val);
+                });
+                return ret;
+            }
+            getDisplayInput(c, system) {
+                return revealKeys.map(k => { var _a; return (_a = this.attr.get(k)) !== null && _a !== void 0 ? _a : 0; });
+            }
+        };
+    }
+}
+class eff_gen_zones extends eff_gen {
+    constructor() {
+        super(...arguments);
+        this.checkInputType = systemRegistry_1.inputType.zone;
+    }
+    /**Down pushes the input to cards */
+    cards(input_f2_new, newActivate) {
+        return this.retarget("card", (p) => p.cards(), input_f2_new, newActivate);
+    }
+    pos(input_f2_new, newActivate) {
+        return this.retarget("pos", (p) => p.pos(), input_f2_new, newActivate);
+    }
+}
+class eff_gen_cards extends eff_gen {
+    constructor() {
+        super(...arguments);
+        this.checkInputType = systemRegistry_1.inputType.card;
+    }
+    zones(input_f2_new, newActivate) {
+        return this.retarget("zone", (p) => p.zones(), input_f2_new, newActivate);
+    }
+    pos(input_f2_new, newActivate) {
+        return this.retarget("pos", (p) => p.pos(), input_f2_new, newActivate);
+    }
+}
+class eff_gen_pos extends eff_gen {
+    constructor() {
+        super(...arguments);
+        this.checkInputType = systemRegistry_1.inputType.position;
+    }
+}
+const eff_manip = {
+    combine(regen1, regen2) {
+    }
+};

package/lib/_queenSystem/handler/localizationHandler.d.ts

@@ -0,0 +1,28 @@
+import { loadOptions } from "../../effectTextParser";
+import Card from "../../types/abstract/gameComponents/card";
+import type Zone from "../../types/abstract/gameComponents/zone";
+import type queenSystem from "../queenSystem";
+import type { dry_system, player_stat } from "../../data/systemRegistry";
+import { parseMode, DisplayComponent } from "../../types/abstract/parser";
+import { LocalizedCard, LocalizedPlayer, LocalizedSystem, LocalizedZone } from "../../types/abstract/serializedGameComponents/Localized";
+import registryHandler from "./registryHandler";
+export default class Localizer {
+    private loader;
+    private parser;
+    private loaded;
+    private __s;
+    get languageID(): import("../../types/abstract/gameComponents/settings").supporttedLanguages;
+    get languageStr(): string;
+    get currLanguageData(): Record<string, string> | undefined;
+    constructor(s: dry_system, regs: registryHandler);
+    load(l: loadOptions): Promise<void>;
+    localizeStandaloneString(s: string, input: (number | string)[]): DisplayComponent[] | undefined;
+    getLocalizedSymbol(s: string): string | undefined;
+    getAndParseLocalizedSymbol(s: string, mode?: parseMode, card?: Card, pid?: number): DisplayComponent[] | undefined;
+    localizeCard(c?: Card, mode?: parseMode): LocalizedCard | undefined;
+    localizeZone(z?: Zone, mode?: parseMode): LocalizedZone | undefined;
+    localizePlayer(player: player_stat, mode?: parseMode): LocalizedPlayer;
+    localizeSystem(s?: queenSystem, mode?: parseMode): LocalizedSystem | undefined;
+    localizeCardFromKey(s: queenSystem | undefined, c_key: string, variants?: string[], mode?: parseMode): LocalizedCard | undefined;
+    get isLoaded(): boolean;
+}