qpremake 1.5.1

package/lib/types/abstract/gameComponents/effect.d.ts

@@ -0,0 +1,82 @@
+import type { dry_card, dry_system, inputData, dry_effect, dry_zone, dry_position, inputData_card, inputData_zone } from "../../../data/systemRegistry";
+import { type Action } from "../../../_queenSystem/handler/actionGenrator";
+import type Card from "./card";
+import type EffectSubtype from "./effectSubtype";
+import type { effectData } from "../../../data/cardRegistry";
+import EffectType from "./effectType";
+import { id_able } from "../../misc";
+import { inputRequester, inputRequester_finalized } from "../../../_queenSystem/handler/actionInputGenerator";
+import { zoneRegistry } from "../../../data/zoneRegistry";
+declare class Effect<inputTupleType extends inputData[] = inputData[]> {
+    id: string;
+    dataID: string;
+    type: EffectType;
+    subTypes: EffectSubtype[];
+    readonly originalData: effectData;
+    isDisabled: boolean;
+    attr: Map<string, number>;
+    get signature_type(): string;
+    get signature_type_subtype(): string;
+    canRespondAndActivate_final(c: dry_card, system: dry_system, a: Action): boolean;
+    activate_final(c: dry_card, s: dry_system, a: Action, input: inputTupleType extends [] ? undefined : inputRequester_finalized<inputTupleType>): Action[];
+    private __cached_input;
+    addedInputConditionMap: Partial<{
+        c(c: dry_card): boolean;
+        e(e: dry_effect): boolean;
+        z(z: dry_zone): boolean;
+        p(p: dry_position): boolean;
+        n(n: number): boolean;
+    }>;
+    /** @final */
+    getInputObj(c: dry_card, s: dry_system, a: Action): inputTupleType extends [] ? undefined : inputRequester<any, inputTupleType>;
+    createInputObj(c: dry_card, s: dry_system, a: Action): inputTupleType extends [] ? undefined : inputRequester<any, inputTupleType>;
+    /** @final */
+    canRespondAndActivate_prelim(c: Card, system: dry_system, a: Action): boolean;
+    /** @final */
+    activate(c: Card, system: dry_system, a: Action, input: inputTupleType extends [] ? undefined : inputRequester_finalized<inputTupleType>): Action[];
+    /** @final */
+    getSubtypeidx(subtypeID: string): number;
+    activateSubtypeSpecificFunc(subtypeIdentifier: string | number, c: Card, system: dry_system, a: Action): Action[];
+    constructor(id: string, dataID: string, type: EffectType, subTypes: EffectSubtype[] | undefined, data: effectData);
+    get displayID(): string;
+    addSubType(st: EffectSubtype): void;
+    removeSubType(stid: string): void;
+    /** @final */
+    disable(): void;
+    /** @final */
+    toDry(): this;
+    /** @final */
+    enable(): void;
+    /** @final */
+    is(p: Function): this is boolean;
+    is(p: id_able): boolean;
+    get count(): number;
+    get doArchtypeCheck(): boolean;
+    get checkLevel(): number;
+    get mult(): number;
+    getDisplayInput(c: dry_card, system: dry_system): (string | number)[];
+    reset(): Action[];
+    toString(spaces?: number): string;
+    cause(s: dry_system, c: dry_card): import("../../../data/systemRegistry").identificationInfo_effect;
+    private overrideActivationCondition?;
+    static listen(f: Exclude<Effect<any>["overrideActivationCondition"], undefined>): typeof Effect;
+    static beforeActivate<T extends new (...p: any[]) => Effect<any>>(this: T, f: (this: Effect<any>, ...p: Parameters<ObjAfterConstructor<T>["activate_final"]>) => void): typeof Effect;
+    /**then
+     * Allows the quick creation of a new effect class
+     * overriding the original action[] result
+     * Does NOT asks for more input
+     * */
+    static then<T extends new (...p: any[]) => Effect<any>>(this: T, f: (this: Effect<any>, res: Action[], ...p: Parameters<ObjAfterConstructor<T>["activate_final"]>) => Action[]): typeof Effect;
+    static thenShares<T extends new (...p: any[]) => Effect<any>>(this: T, f: (this: Effect<any>, res: Action[], ...p: [...Parameters<ObjAfterConstructor<T>["activate_final"]>, Effect<any>]) => [string, number]): typeof Effect;
+    static implyCondition<T extends new (...p: any[]) => Effect<any>, K extends keyof Effect["addedInputConditionMap"]>(this: T, type: K, cond: (this: Effect<any>, p: Parameters<Exclude<Effect["addedInputConditionMap"][K], undefined>>[0], ...p2: Parameters<Exclude<Effect["overrideActivationCondition"], undefined>>) => boolean): T;
+    static removeInput<T extends new (...p: any[]) => Effect<any>, oldInputType extends inputData[] = T extends new (...p: any[]) => Effect<infer X> ? (X extends [] ? never : X) : never>(this: T, converter: (this: Effect<any>, ...p: [dry_card, dry_system, Action]) => oldInputType | oldInputType[]): typeof Effect<[]>;
+    static retarget<newInputType extends inputData[], T extends new (...p: any[]) => Effect<any>, oldInputType extends inputData[] = T extends new (...p: any[]) => Effect<infer X> ? (X extends [] ? never : X) : never>(this: T, newInputFunc: (this: Effect<any>, ...p: [dry_card, dry_system, Action]) => inputRequester<any, newInputType>, converter: (this: Effect<any>, newInput: newInputType, ...p: [dry_card, dry_system, Action]) => oldInputType | oldInputType[]): typeof Effect<newInputType>;
+    static toOthersOfSameField(this: typeof Effect<inputData_card[]>, filter?: (c: dry_card, thisCard: dry_card, s: dry_system, a: Action) => boolean): typeof Effect;
+    static toAllEnemies(this: typeof Effect<inputData_card[]>, filter?: (c: dry_card, thisCard: dry_card, s: dry_system, a: Action) => boolean): typeof Effect;
+    static toAllOfZone(this: typeof Effect<inputData_card[]>, newInputFunc: Effect<[inputData_zone]>["createInputObj"], filter?: (c: dry_card, thisCard: dry_card, s: dry_system, a: Action) => boolean): typeof Effect;
+    static toAllOfSpecificZone(this: typeof Effect<inputData_card[]>, type: zoneRegistry, filter?: (c: dry_card, thisCard: dry_card, s: dry_system, a: Action) => boolean): typeof Effect;
+    static toThisCard(this: typeof Effect<inputData_card[]>): typeof Effect;
+    static moreInput<originalInput extends Exclude<inputData[], []>, extraInput extends Exclude<inputData[], []>>(this: typeof Effect<originalInput>, moreInputFunc: (this: Effect<any>, c: dry_card, s: dry_system, a: Action) => inputRequester<any, extraInput>, handler?: (this: Effect<any>, c: dry_card, s: dry_system, a: Action, input: [...originalInput, ...extraInput]) => Action[]): typeof Effect<[...originalInput, ...extraInput]>;
+}
+type ObjAfterConstructor<T> = T extends new (...p: any[]) => infer K ? K : never;
+export default Effect;

package/lib/types/abstract/gameComponents/effect.js

@@ -0,0 +1,331 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const actionGenrator_1 = require("../../../_queenSystem/handler/actionGenrator");
+//some effects can modify event data 
+//so in general, activate takes in an event and spits out an event
+const actionInputGenerator_1 = require("../../../_queenSystem/handler/actionInputGenerator");
+const actionInputRequesterGenerator_1 = __importDefault(require("../../../_queenSystem/handler/actionInputRequesterGenerator"));
+class Effect {
+    get signature_type() {
+        return this.type.dataID;
+    }
+    get signature_type_subtype() {
+        const sep = "===";
+        return this.signature_type + sep + this.subTypes.map(i => i.dataID).join(sep);
+    }
+    //actual effects override these two
+    canRespondAndActivate_final(c, system, a) { return this.constructor.name !== "Effect"; }
+    activate_final(c, s, a, input) { return []; }
+    ;
+    /** @final */
+    getInputObj(c, s, a) {
+        if (this.__cached_input.hasValue)
+            return this.__cached_input.value;
+        this.__cached_input = {
+            hasValue: true,
+            value: this.createInputObj(c, s, a)
+        };
+        return this.__cached_input.value;
+    }
+    //createInputObj should be deterministic
+    //activate once per activate call
+    createInputObj(c, s, a) {
+        return undefined;
+    }
+    //Update 1.2.6 : Move the condition closer to the activate, i.e inside it
+    //to avoid condition conflicts
+    //can repond -> 2 functions, canRespond_prelim and canRespond_final
+    /** @final */
+    canRespondAndActivate_prelim(c, system, a) {
+        let res = -1;
+        let trueForceFlag = false;
+        let falseForceFlag = false;
+        const overrideIndexes = [];
+        let skipTypeCheck = false;
+        if (this.isDisabled)
+            return false;
+        if (!c.canAct)
+            return false;
+        for (let i = 0; i < this.subTypes.length; i++) {
+            //if any non-disabled subtype returns returns that instead
+            if (this.subTypes[i].isDisabled)
+                continue;
+            res = this.subTypes[i].onEffectCheckCanActivate(c, this, system, a);
+            if (res === -1)
+                continue;
+            if (res === -2) {
+                skipTypeCheck = true;
+                continue;
+            }
+            if (res)
+                trueForceFlag = true;
+            else
+                falseForceFlag = true;
+            overrideIndexes.push(i);
+        }
+        //resolvin conflict
+        if (trueForceFlag && falseForceFlag) {
+            //conflict exists
+            //false is prioritized
+            // return new subTypeOverrideConflict(c.id, this.id, overrideIndexes)
+            return false;
+        }
+        if (trueForceFlag)
+            return true;
+        if (falseForceFlag)
+            return false;
+        if (!skipTypeCheck) {
+            res = this.type.canRespondAndActivate(this, c, system, a);
+            if (res !== -1)
+                return res;
+        }
+        //has input check
+        const gen = this.getInputObj(c, system, a);
+        if (gen !== undefined && !gen.hasInput())
+            return false;
+        // return this.canRespondAndActivate_final(c, system, a);
+        return true;
+    }
+    /** @final */
+    activate(c, system, a, input) {
+        this.__cached_input = {
+            hasValue: false
+        };
+        if (this.overrideActivationCondition && !this.overrideActivationCondition.bind(this)(c, system, a)) {
+            return [];
+        }
+        if (!this.canRespondAndActivate_final(c, system, a)) {
+            return [];
+        }
+        if (this.isDisabled)
+            return [];
+        if (!c.canAct)
+            return [];
+        let res = -1;
+        const appenddedRes = [];
+        for (let i = 0; i < this.subTypes.length; i++) {
+            if (this.subTypes[i].isDisabled)
+                continue;
+            res = this.subTypes[i].onEffectActivate(c, this, system, a);
+            if (res === -1)
+                continue;
+            appenddedRes.push(...res);
+        }
+        const final = this.activate_final(c, system, a, input);
+        this.type.parseAfterActivate(this, c, system, final);
+        this.subTypes.forEach(st => st.parseAfterActivate(c, this, system, final));
+        return final;
+    }
+    ;
+    /** @final */
+    getSubtypeidx(subtypeID) {
+        for (let i = 0; i > this.subTypes.length; i++) {
+            if (this.subTypes[i].dataID === subtypeID)
+                return i;
+        }
+        return -1;
+    }
+    activateSubtypeSpecificFunc(subtypeIdentifier, c, system, a) {
+        if (typeof subtypeIdentifier === "string") {
+            subtypeIdentifier = this.getSubtypeidx(subtypeIdentifier);
+        }
+        if (subtypeIdentifier < 0)
+            return [];
+        return this.subTypes[subtypeIdentifier].activateSpecificFunctionality(c, this, system, a);
+    }
+    constructor(id, dataID, type, subTypes = [], data) {
+        this.isDisabled = false; //I DO NOT LIKE THIS NAME
+        this.__cached_input = {
+            hasValue: false
+        };
+        //@unmodifiable
+        this.addedInputConditionMap = {};
+        this.id = id;
+        this.type = type;
+        this.subTypes = subTypes;
+        this.dataID = dataID;
+        this.originalData = data;
+        const k = Object.entries(data).filter(([_, val]) => typeof val === "number");
+        this.attr = new Map(k);
+    }
+    get displayID() { var _a; return (_a = this.originalData.displayID_default) !== null && _a !== void 0 ? _a : this.dataID; }
+    addSubType(st) {
+        this.subTypes.push(st);
+    }
+    removeSubType(stid) {
+        this.subTypes = this.subTypes.filter(i => i.dataID !== stid);
+    }
+    /** @final */
+    disable() {
+        this.isDisabled = true;
+    }
+    /** @final */
+    toDry() {
+        return this;
+    }
+    /** @final */
+    enable() {
+        this.isDisabled = false;
+    }
+    is(p) {
+        return typeof p === "function" ? this instanceof p : this.id === p.id;
+    }
+    //common variables
+    get count() { var _a; return (_a = this.attr.get("count")) !== null && _a !== void 0 ? _a : 0; }
+    get doArchtypeCheck() { return this.attr.get("doArchtypeCheck") != 0; } //!= is intentional to allow undefine = 0
+    get checkLevel() { var _a; return (_a = this.attr.get("checkLevel")) !== null && _a !== void 0 ? _a : 0; }
+    get mult() { var _a; return (_a = this.attr.get("mult")) !== null && _a !== void 0 ? _a : 1; }
+    //effect types:
+    // + trigger : 
+    // responds to "effect resolution"
+    // adds each action return as a new tree
+    // + passive :
+    // responds to "effect activation"
+    // may modifies the action it responds to
+    // adds the effect to the current node as a child node to the current node
+    // + chained trigger : 
+    // responds to "effect activation"
+    // adds a "activate effect" action as a child node to the current node, which activates this one
+    //^ implemented
+    getDisplayInput(c, system) {
+        return Object.keys(this.originalData).sort().map(k => { var _a; return (_a = this.attr.get(k)) !== null && _a !== void 0 ? _a : 0; });
+    }
+    reset() {
+        const res = [];
+        this.subTypes.forEach(i => res.push(...i.reset()));
+        return res;
+    }
+    toString(spaces = 2) {
+        return JSON.stringify({
+            dataID: this.dataID,
+            subTypes: this.subTypes,
+            // desc : this.desc,
+            attr: JSON.stringify(Array.from(Object.entries(this.attr)))
+        }, null, spaces);
+    }
+    cause(s, c) {
+        return actionGenrator_1.actionFormRegistry.effect(s, c, this);
+    }
+    static listen(f) {
+        return class ExtendedEff extends this {
+            constructor(...p) {
+                super(...p);
+                this.overrideActivationCondition = f.bind(this);
+            }
+        };
+    }
+    static beforeActivate(f) {
+        return class ExtendedEff extends this {
+            activate_final(...p) {
+                const k = p;
+                (f.bind(this))(...k);
+                return super.activate_final(...k);
+            }
+        };
+    }
+    /**then
+     * Allows the quick creation of a new effect class
+     * overriding the original action[] result
+     * Does NOT asks for more input
+     * */
+    static then(f) {
+        return class ExtendedEff extends this {
+            activate_final(...p) {
+                const k = p;
+                const res = super.activate_final(...k);
+                return (f.bind(this))(res, ...k);
+            }
+        };
+    }
+    static thenShares(f) {
+        return class ExtendedEff extends this {
+            activate_final(...p) {
+                const k = p;
+                const res = super.activate_final(...k);
+                const [key, val] = f.bind(this)(res, ...p, this);
+                p[0].addShareMemory(this, key, val);
+                return res;
+            }
+        };
+    }
+    static implyCondition(type, cond) {
+        return class ExtendedEff extends this {
+            createInputObj(c, s, a) {
+                this.addedInputConditionMap[type] =
+                    ((c, s, a) => (target) => cond.bind(this)(target, c, s, a))(c, s, a);
+                const res = super.createInputObj(c, s, a);
+                delete this.addedInputConditionMap[type];
+                return res;
+            }
+        };
+    }
+    static removeInput(converter) {
+        const originalClass = this; //type dance to convert old -> new
+        return class ExtendedEff extends originalClass {
+            createInputObj(c, s, a) {
+                return undefined;
+            }
+            activate_final(c, s, a) {
+                const oldInput = converter.bind(this)(c, s, a);
+                const testObj = oldInput[0];
+                if (!testObj || !Array.isArray(testObj))
+                    return super.activate_final(c, s, a, { next: () => oldInput });
+                return testObj.flatMap(o => super.activate_final(c, s, a, { next: () => o }));
+            }
+        };
+    }
+    static retarget(newInputFunc, converter) {
+        const originalClass = this; //type dance to convert old -> new
+        return class ExtendedEff extends originalClass {
+            createInputObj(c, s, a) {
+                return newInputFunc.bind(this)(c, s, a);
+            }
+            activate_final(c, s, a, input) {
+                const r = input === null || input === void 0 ? void 0 : input.next();
+                if (!r)
+                    return [];
+                const oldInput = converter.bind(this)(r, c, s, a);
+                const testObj = oldInput[0];
+                if (!testObj || !Array.isArray(testObj))
+                    return super.activate_final(c, s, a, { next: () => oldInput });
+                return testObj.flatMap(o => super.activate_final(c, s, a, { next: () => o }));
+            }
+        };
+    }
+    static toOthersOfSameField(filter) {
+        return this.removeInput((c, s, a) => s.getZoneOf(c).cardArr_filtered.filter(c1 => c1.id !== c.id && (!filter || filter(c1, c, s, a))).map(c1 => actionInputGenerator_1.inputFormRegistry.card(s, c1)));
+    }
+    static toAllEnemies(filter) {
+        return this.toAllOfZone((c, s, a) => actionInputRequesterGenerator_1.default.oppositeZoneTo(s, c).once(), filter);
+    }
+    static toAllOfZone(newInputFunc, filter) {
+        return this.retarget(newInputFunc, (z, c, s, a) => filter ?
+            z[0].data.zone.cardArr_filtered.filter(c1 => filter(c1, c, s, a)).map(c => actionInputGenerator_1.inputFormRegistry.card(s, c)) :
+            z[0].data.zone.cardArr_filtered.map(c => actionInputGenerator_1.inputFormRegistry.card(s, c)));
+    }
+    static toAllOfSpecificZone(type, filter) {
+        return this.toAllOfZone((c, s, a) => actionInputRequesterGenerator_1.default.specificType(s, c, type).once(), filter);
+    }
+    static toThisCard() {
+        return this.removeInput((c, s, a) => [actionInputGenerator_1.inputFormRegistry.card(s, c)]);
+    }
+    static moreInput(moreInputFunc, handler) {
+        const originalClass = this;
+        return class ExtendedEff extends originalClass {
+            createInputObj(c, s, a) {
+                this.___input_original = super.createInputObj(c, s, a);
+                return this.___input_original.merge(moreInputFunc.bind(this)(c, s, a));
+            }
+            activate_final(c, s, a, input) {
+                const a1 = super.activate_final(c, s, a, this.___input_original);
+                if (!handler)
+                    return a1;
+                return a1.concat(handler.bind(this)(c, s, a, input.next()));
+            }
+        };
+    }
+}
+exports.default = Effect;

package/lib/types/abstract/gameComponents/effectSubtype.d.ts

@@ -0,0 +1,22 @@
+import type Card from "./card";
+import type { dry_system } from "../../../data/systemRegistry";
+import type { Action } from "../../../_queenSystem/handler/actionGenrator";
+import type Effect from "./effect";
+import { dry_effectSubType } from "../../../data/systemRegistry";
+type doNothingCode = -1;
+type doNothingAndSkipTypeCheckCode = -2;
+declare class EffectSubtype {
+    dataID: string;
+    isDisabled: boolean;
+    constructor(dataID: string);
+    onEffectCheckCanActivate(c: Card, e: Effect, system: dry_system, a: Action): doNothingCode | doNothingAndSkipTypeCheckCode | boolean;
+    onEffectActivate(c: Card, e: Effect, system: dry_system, a: Action): doNothingCode | Action[];
+    parseAfterActivate(c: Card, e: Effect, system: dry_system, res: Action[]): void;
+    activateSpecificFunctionality(c: Card, e: Effect, system: dry_system, a: Action): Action[];
+    disable(): void;
+    enable(): void;
+    reset(): Action[];
+    toDry(): dry_effectSubType;
+    is(p: dry_effectSubType): boolean;
+}
+export default EffectSubtype;

package/lib/types/abstract/gameComponents/effectSubtype.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class EffectSubtype {
+    constructor(dataID) {
+        this.isDisabled = false;
+        this.dataID = dataID;
+    }
+    //the job of this bullshit is to do additonal stuff before the two main functions
+    //of effect and may or may not override a forced return early
+    //remember, what returns here is simply the extra functionality of the subtype
+    //we do not care here what the fuck the effect do
+    onEffectCheckCanActivate(c, e, system, a) {
+        return -1;
+    }
+    onEffectActivate(c, e, system, a) {
+        //I hereby declare that
+        //subtypes cannot override effects
+        //whatever returns here shall be appended
+        return -1;
+    }
+    parseAfterActivate(c, e, system, res) { }
+    //this is for subtype specific functionality
+    activateSpecificFunctionality(c, e, system, a) { return []; }
+    disable() {
+        this.isDisabled = true;
+    }
+    enable() {
+        this.isDisabled = false;
+    }
+    reset() {
+        return [];
+    }
+    toDry() {
+        return this;
+    }
+    is(p) {
+        return p.dataID === this.dataID;
+    }
+}
+exports.default = EffectSubtype;

package/lib/types/abstract/gameComponents/effectType.d.ts

@@ -0,0 +1,11 @@
+import type Card from "./card";
+import type { dry_card, dry_effect, dry_system } from "../../../data/systemRegistry";
+import type { Action } from "../../../_queenSystem/handler/actionGenrator";
+type doNothingAndPassCode = -1;
+export default class EffectType {
+    dataID: string;
+    constructor(dataID: string);
+    canRespondAndActivate(eff: dry_effect, c: dry_card, system: dry_system, a: Action): doNothingAndPassCode | boolean;
+    parseAfterActivate(eff: dry_effect, c: Card, system: dry_system, res: Action[]): void;
+}
+export {};

package/lib/types/abstract/gameComponents/effectType.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class EffectType {
+    constructor(dataID) { this.dataID = dataID; }
+    canRespondAndActivate(eff, c, system, a) { return -1; }
+    parseAfterActivate(eff, c, system, res) { }
+}
+exports.default = EffectType;

package/lib/types/abstract/gameComponents/settings.d.ts

@@ -0,0 +1,80 @@
+import { partitionActivationBehavior } from "../../../data/cardRegistry";
+export declare enum partitionSetting {
+    "manual_mapping_no_ghost" = 0,
+    "manual_mapping_with_ghost" = 1,//ghosts are gathered into a partition
+    "manual_mapping_with_ghost_spread" = 2,//ghosts are gathered one to one into multiple partition
+    "auto_mapping_types" = 3,//gather like-typed effects into a partition, no care ab subtype, sorted in enum order
+    "auto_mapping_subtypes" = 4,//gather like-subtyped and like-typed effects into a partition, sorted in type enum -> then sutype enum  
+    "auto_mapping_one_to_one" = 5,//one to one map
+    "auto_mapping_ygo" = 6
+}
+export type partitionSetting_manual = partitionSetting.manual_mapping_no_ghost | partitionSetting.manual_mapping_with_ghost | partitionSetting.manual_mapping_with_ghost_spread;
+export type partitionSetting_auto = partitionSetting.auto_mapping_one_to_one | partitionSetting.auto_mapping_subtypes | partitionSetting.auto_mapping_types | partitionSetting.auto_mapping_ygo;
+declare enum supporttedLanguages {
+    "English" = 0,
+    "Japanese" = 1,
+    "testLang" = 2
+}
+declare enum id_style {
+    "MINIMAL" = 0,//absolute bare minimum for everything to function (randID + count)
+    "REDUCED" = 1,// dataID + minimal
+    "FULL" = 2
+}
+declare enum auto_input_option {
+    none = 0,//no assumtion, prompt input even if valid choices is only one
+    default = 1,//if valid choices is one, skip that input
+    first = 2,//auto chooses the first option available
+    last = 3,//auto chooses the last option
+    random = 4
+}
+interface Setting {
+    languageID: supporttedLanguages;
+    dynamic_id_len: number;
+    id_style: id_style;
+    id_separator: string;
+    max_id_count: number;
+    effectFolder: string;
+    effectFiles: string[];
+    mods: string[];
+    modFolder_game: string;
+    modFolder_parser: string;
+    localizationFolder: string;
+    ignore_undefined_subtype: boolean;
+    ignore_undefined_effect: boolean;
+    show_negative_stat: boolean;
+    auto_input: auto_input_option;
+    ignore_invalid_partition_mapping: boolean;
+    global_partition_setting: partitionSetting;
+    default_partition_behavior: partitionActivationBehavior;
+    parser_modules: string[];
+    singleton_effect_subtype: boolean;
+    singleton_effect_type: boolean;
+    spawn_instanced_zones_per_player: boolean;
+}
+declare class defaultSetting implements Setting {
+    languageID: supporttedLanguages;
+    mods: never[];
+    dynamic_id_len: number;
+    id_style: id_style;
+    id_separator: string;
+    max_id_count: number;
+    effectFolder: string;
+    effectFiles: string[];
+    modFolder_game: string;
+    modFolder_parser: string;
+    localizationFolder: string;
+    ignore_undefined_subtype: boolean;
+    ignore_undefined_effect: boolean;
+    show_negative_stat: boolean;
+    ignore_invalid_partition_mapping: boolean;
+    global_partition_setting: partitionSetting;
+    default_partition_behavior: partitionActivationBehavior;
+    parser_modules: string[];
+    singleton_effect_subtype: boolean;
+    singleton_effect_type: boolean;
+    spawn_instanced_zones_per_player: boolean;
+    auto_input: auto_input_option;
+}
+declare const _default: defaultSetting;
+export default _default;
+export { Setting, defaultSetting, supporttedLanguages, auto_input_option, id_style, };

package/lib/types/abstract/gameComponents/settings.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.id_style = exports.auto_input_option = exports.supporttedLanguages = exports.defaultSetting = exports.partitionSetting = void 0;
+const cardRegistry_1 = require("../../../data/cardRegistry");
+var partitionSetting;
+(function (partitionSetting) {
+    partitionSetting[partitionSetting["manual_mapping_no_ghost"] = 0] = "manual_mapping_no_ghost";
+    partitionSetting[partitionSetting["manual_mapping_with_ghost"] = 1] = "manual_mapping_with_ghost";
+    partitionSetting[partitionSetting["manual_mapping_with_ghost_spread"] = 2] = "manual_mapping_with_ghost_spread";
+    partitionSetting[partitionSetting["auto_mapping_types"] = 3] = "auto_mapping_types";
+    partitionSetting[partitionSetting["auto_mapping_subtypes"] = 4] = "auto_mapping_subtypes";
+    partitionSetting[partitionSetting["auto_mapping_one_to_one"] = 5] = "auto_mapping_one_to_one";
+    partitionSetting[partitionSetting["auto_mapping_ygo"] = 6] = "auto_mapping_ygo"; //maps all effects to one partition (gonna be hella fun)
+})(partitionSetting || (exports.partitionSetting = partitionSetting = {}));
+var supporttedLanguages;
+(function (supporttedLanguages) {
+    supporttedLanguages[supporttedLanguages["English"] = 0] = "English";
+    supporttedLanguages[supporttedLanguages["Japanese"] = 1] = "Japanese";
+    supporttedLanguages[supporttedLanguages["testLang"] = 2] = "testLang";
+})(supporttedLanguages || (exports.supporttedLanguages = supporttedLanguages = {}));
+var id_style;
+(function (id_style) {
+    id_style[id_style["MINIMAL"] = 0] = "MINIMAL";
+    id_style[id_style["REDUCED"] = 1] = "REDUCED";
+    id_style[id_style["FULL"] = 2] = "FULL";
+})(id_style || (exports.id_style = id_style = {}));
+var auto_input_option;
+(function (auto_input_option) {
+    auto_input_option[auto_input_option["none"] = 0] = "none";
+    auto_input_option[auto_input_option["default"] = 1] = "default";
+    //the below skips all input prompting
+    auto_input_option[auto_input_option["first"] = 2] = "first";
+    auto_input_option[auto_input_option["last"] = 3] = "last";
+    auto_input_option[auto_input_option["random"] = 4] = "random";
+})(auto_input_option || (exports.auto_input_option = auto_input_option = {}));
+class defaultSetting {
+    constructor() {
+        this.languageID = supporttedLanguages.English;
+        this.mods = []; //no mods
+        this.dynamic_id_len = 5;
+        this.id_style = id_style.MINIMAL;
+        this.id_separator = '';
+        this.max_id_count = 65536;
+        this.effectFolder = "../../specificEffects";
+        this.effectFiles = [
+            "e_test",
+            "e_status",
+            "e_generic",
+            "e_fruit",
+        ];
+        this.modFolder_game = "../_mods/gameModules";
+        this.modFolder_parser = "../_mods/parserModules";
+        this.localizationFolder = "../../_localizationFiles";
+        this.ignore_undefined_subtype = true;
+        this.ignore_undefined_effect = true;
+        this.show_negative_stat = true;
+        this.ignore_invalid_partition_mapping = false;
+        this.global_partition_setting = partitionSetting.manual_mapping_no_ghost;
+        this.default_partition_behavior = cardRegistry_1.partitionActivationBehavior.strict;
+        this.parser_modules = ["qpOriginal"];
+        this.singleton_effect_subtype = true;
+        this.singleton_effect_type = true;
+        this.spawn_instanced_zones_per_player = false;
+        this.auto_input = auto_input_option.default;
+    }
+}
+exports.defaultSetting = defaultSetting;
+exports.default = new defaultSetting();