qpremake 1.5.1

package/lib/types/abstract/parser/component.js

@@ -0,0 +1,132 @@
+"use strict";
+//specifies the general textComponent
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolComponent = exports.ReferenceComponent = exports.IconComponent = exports.ImageComponent = exports.NumberComponent = exports.TextComponent = exports.DisplayComponent = exports.componentID = exports.iconID = void 0;
+var iconID;
+(function (iconID) {
+    //arrows
+    iconID[iconID["arrowUp"] = 0] = "arrowUp";
+    iconID[iconID["arrowDown"] = 1] = "arrowDown";
+    iconID[iconID["arrowLeft"] = 2] = "arrowLeft";
+    iconID[iconID["arrowRight"] = 3] = "arrowRight";
+    //double arrows
+    iconID[iconID["doubleArrowDown"] = 10] = "doubleArrowDown";
+    iconID[iconID["doubleArrowUp"] = 11] = "doubleArrowUp";
+    iconID[iconID["doubleArrowLeft"] = 12] = "doubleArrowLeft";
+    iconID[iconID["doubleArrowRight"] = 13] = "doubleArrowRight";
+    //effect icon
+    iconID[iconID["bonded"] = 100] = "bonded";
+    iconID[iconID["cached"] = 101] = "cached";
+    iconID[iconID["chain"] = 102] = "chain";
+    iconID[iconID["consumable"] = 103] = "consumable";
+    iconID[iconID["death"] = 104] = "death";
+    iconID[iconID["defense"] = 105] = "defense";
+    iconID[iconID["dragoonLink"] = 106] = "dragoonLink";
+    iconID[iconID["effect_condition"] = 107] = "effect_condition";
+    iconID[iconID["exclusive"] = 108] = "exclusive";
+    iconID[iconID["execute"] = 109] = "execute";
+    iconID[iconID["hardUnique"] = 110] = "hardUnique";
+    iconID[iconID["init"] = 111] = "init";
+    iconID[iconID["instant"] = 112] = "instant";
+    iconID[iconID["lock"] = 113] = "lock";
+    iconID[iconID["manual"] = 114] = "manual";
+    iconID[iconID["once"] = 115] = "once";
+    iconID[iconID["passive"] = 116] = "passive";
+    iconID[iconID["preload"] = 117] = "preload";
+    //^ after reprogram or start game, auto draw into hand, 
+    // dont count towards the draw limit
+    iconID[iconID["trigger"] = 118] = "trigger";
+    iconID[iconID["unique"] = 119] = "unique";
+    iconID[iconID["void"] = 120] = "void";
+    //damage type
+    iconID[iconID["dmg_magic"] = 200] = "dmg_magic";
+    iconID[iconID["dmg_phys"] = 201] = "dmg_phys";
+    //misc
+    iconID[iconID["crash"] = 1000] = "crash";
+    iconID[iconID["loot"] = 1001] = "loot";
+    iconID[iconID["player_health"] = 1002] = "player_health";
+})(iconID || (exports.iconID = iconID = {}));
+var componentID;
+(function (componentID) {
+    componentID[componentID["error"] = -1] = "error";
+    componentID[componentID["number"] = 1] = "number";
+    componentID[componentID["text"] = 2] = "text";
+    componentID[componentID["image"] = 3] = "image";
+    componentID[componentID["reference"] = 4] = "reference";
+    componentID[componentID["symbol"] = 5] = "symbol";
+})(componentID || (exports.componentID = componentID = {}));
+class DisplayComponent {
+    constructor(id = componentID.error, errMsg, fromCmd, raw) {
+        this.sectionIDs = [];
+        this.id = id;
+        if (this.id == componentID.error || errMsg) {
+            this.errorFlag = true;
+            this.errorMsg = errMsg ? errMsg : "Unknown component";
+        }
+        else {
+            this.errorFlag = false;
+            this.errorMsg = "";
+        }
+        this.fromCmd = (fromCmd) ? fromCmd : "";
+        this.raw = (raw) ? raw : "";
+    }
+    addSectionID(newID) {
+        if (typeof newID == "string")
+            this.sectionIDs.push(newID);
+        else
+            this.sectionIDs.push(...newID);
+        return this;
+    }
+    is(id) {
+        return this.id === componentID[id];
+    }
+}
+exports.DisplayComponent = DisplayComponent;
+class TextComponent extends DisplayComponent {
+    constructor(str, errMsg, fromCmd, raw) {
+        super(componentID.text, errMsg, fromCmd, raw);
+        this.num = -100;
+        this.str = str;
+        const num = Number(str);
+        if (!isNaN(num) && str.trim().length) {
+            this.id = componentID.number;
+            this.num = Number(str);
+        }
+    }
+}
+exports.TextComponent = TextComponent;
+class NumberComponent extends DisplayComponent {
+    constructor(num, errMsg, fromCmd, raw) {
+        super(componentID.number, errMsg, fromCmd, raw);
+        this.num = num;
+    }
+}
+exports.NumberComponent = NumberComponent;
+class ImageComponent extends DisplayComponent {
+    constructor(url, errMsg, fromCmd, raw) {
+        super(componentID.image, errMsg, fromCmd, raw);
+        this.url = url;
+    }
+}
+exports.ImageComponent = ImageComponent;
+class IconComponent extends ImageComponent {
+    constructor(id, errMsg, fromCmd, raw) {
+        super(`https://raw.githubusercontent.com/qpProject/qpProject.github.io/refs/heads/main/icons/${iconID[id]}.png`, errMsg, fromCmd, raw);
+        this.iconID = id;
+    }
+}
+exports.IconComponent = IconComponent;
+class ReferenceComponent extends DisplayComponent {
+    constructor(ref, errMsg, fromCmd, raw) {
+        super(componentID.reference, errMsg, fromCmd, raw);
+        this.ref = ref;
+    }
+}
+exports.ReferenceComponent = ReferenceComponent;
+class SymbolComponent extends DisplayComponent {
+    constructor(id, errMsg, fromCmd, raw) {
+        super(componentID.symbol, errMsg, fromCmd, raw);
+        this.symbolID = id;
+    }
+}
+exports.SymbolComponent = SymbolComponent;

package/lib/types/abstract/parser/index.d.ts

@@ -0,0 +1,6 @@
+import { iconID, DisplayComponent, componentID, TextComponent, NumberComponent, ImageComponent, ReferenceComponent, IconComponent, SymbolComponent } from "./component";
+import modPack from "./modPack";
+import { ParserModule } from "../../mods/effectTextParserModule";
+import moduleInputObject from "./moduleInputObject";
+import { parseMode, parseOptions, loadOptions, lib_parse_option } from "./options";
+export { iconID, DisplayComponent, componentID, TextComponent, NumberComponent, ImageComponent, ReferenceComponent, IconComponent, SymbolComponent, ParserModule, modPack, moduleInputObject, parseMode, parseOptions, loadOptions, parseMode as mode, lib_parse_option, };

package/lib/types/abstract/parser/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lib_parse_option = exports.mode = exports.loadOptions = exports.parseOptions = exports.parseMode = exports.moduleInputObject = exports.modPack = exports.ParserModule = exports.SymbolComponent = exports.IconComponent = exports.ReferenceComponent = exports.ImageComponent = exports.NumberComponent = exports.TextComponent = exports.componentID = exports.DisplayComponent = exports.iconID = void 0;
+const component_1 = require("./component");
+Object.defineProperty(exports, "iconID", { enumerable: true, get: function () { return component_1.iconID; } });
+Object.defineProperty(exports, "DisplayComponent", { enumerable: true, get: function () { return component_1.DisplayComponent; } });
+Object.defineProperty(exports, "componentID", { enumerable: true, get: function () { return component_1.componentID; } });
+Object.defineProperty(exports, "TextComponent", { enumerable: true, get: function () { return component_1.TextComponent; } });
+Object.defineProperty(exports, "NumberComponent", { enumerable: true, get: function () { return component_1.NumberComponent; } });
+Object.defineProperty(exports, "ImageComponent", { enumerable: true, get: function () { return component_1.ImageComponent; } });
+Object.defineProperty(exports, "ReferenceComponent", { enumerable: true, get: function () { return component_1.ReferenceComponent; } });
+Object.defineProperty(exports, "IconComponent", { enumerable: true, get: function () { return component_1.IconComponent; } });
+Object.defineProperty(exports, "SymbolComponent", { enumerable: true, get: function () { return component_1.SymbolComponent; } });
+const modPack_1 = __importDefault(require("./modPack"));
+exports.modPack = modPack_1.default;
+const effectTextParserModule_1 = require("../../mods/effectTextParserModule");
+Object.defineProperty(exports, "ParserModule", { enumerable: true, get: function () { return effectTextParserModule_1.ParserModule; } });
+const moduleInputObject_1 = __importDefault(require("./moduleInputObject"));
+exports.moduleInputObject = moduleInputObject_1.default;
+const options_1 = require("./options");
+Object.defineProperty(exports, "parseMode", { enumerable: true, get: function () { return options_1.parseMode; } });
+Object.defineProperty(exports, "mode", { enumerable: true, get: function () { return options_1.parseMode; } });
+Object.defineProperty(exports, "parseOptions", { enumerable: true, get: function () { return options_1.parseOptions; } });
+Object.defineProperty(exports, "loadOptions", { enumerable: true, get: function () { return options_1.loadOptions; } });
+Object.defineProperty(exports, "lib_parse_option", { enumerable: true, get: function () { return options_1.lib_parse_option; } });

package/lib/types/abstract/parser/modPack.d.ts

@@ -0,0 +1,21 @@
+import { DisplayComponent } from "./component";
+import { ParserModule } from "../../mods/effectTextParserModule";
+import moduleInputObject from "./moduleInputObject";
+import { parseOptions } from "./options";
+import type { nestedTree } from "../../misc";
+declare class modPack extends ParserModule {
+    private moduleMap;
+    protected moduleArr: ParserModule[];
+    cmdName: string[];
+    requiredAttr: string[][];
+    doCheckRequiredAttr: boolean;
+    private doCheckRequiredAttrArr;
+    private cmdTrueIndex;
+    protected loadModules(): void;
+    generateInputObj(cmdIndex: number, attrObj: {
+        [attr: string]: string;
+    }, children: nestedTree<DisplayComponent>): moduleInputObject | undefined;
+    isValidAttr(cmdIndex: number, attrName: string, attr: string): boolean;
+    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): nestedTree<DisplayComponent>;
+}
+export default modPack;

package/lib/types/abstract/parser/modPack.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const effectTextParserModule_1 = require("../../mods/effectTextParserModule");
+class modPack extends effectTextParserModule_1.ParserModule {
+    constructor() {
+        super(...arguments);
+        this.moduleMap = new Map();
+        this.moduleArr = [];
+        this.cmdName = [];
+        this.requiredAttr = [];
+        this.doCheckRequiredAttr = false; //not used
+        this.doCheckRequiredAttrArr = [];
+        this.cmdTrueIndex = [];
+    }
+    loadModules() {
+        this.moduleArr.forEach((i, index) => {
+            var _a;
+            i.cmdName.forEach(j => {
+                this.moduleMap.set(j, index);
+            });
+            for (let k = 0; k < i.cmdName.length; k++) {
+                this.cmdName.push(i.cmdName[k]);
+                this.requiredAttr.push((_a = i.requiredAttr[k]) !== null && _a !== void 0 ? _a : []);
+                this.doCheckRequiredAttrArr.push(i.doCheckRequiredAttr);
+                this.cmdTrueIndex.push(k);
+            }
+        });
+    }
+    generateInputObj(cmdIndex, attrObj, children) {
+        const moduleIndex = this.moduleMap.get(this.cmdName[cmdIndex]);
+        if (moduleIndex === undefined)
+            return undefined;
+        return this.moduleArr[moduleIndex].generateInputObj(this.cmdTrueIndex[cmdIndex], attrObj, children);
+    }
+    isValidAttr(cmdIndex, attrName, attr) {
+        const moduleIndex = this.moduleMap.get(this.cmdName[cmdIndex]);
+        if (moduleIndex === undefined)
+            return false;
+        return this.moduleArr[moduleIndex].isValidAttr(this.cmdTrueIndex[cmdIndex], attrName, attr);
+    }
+    evaluate(cmd, args, option, raw) {
+        const moduleIndex = this.moduleMap.get(cmd);
+        if (moduleIndex === undefined)
+            return [];
+        return this.moduleArr[moduleIndex].evaluate(cmd, args, option, raw);
+    }
+}
+exports.default = modPack;

package/lib/types/abstract/parser/moduleInputObject.d.ts

@@ -0,0 +1,12 @@
+import type { DisplayComponent } from "./component";
+import type { nestedTree } from "../../misc";
+export default class moduleInputObject {
+    private paramMap;
+    private chilren;
+    constructor(attrObj: {
+        [attr: string]: string;
+    }, children: nestedTree<DisplayComponent>);
+    hasAttr(key: string): boolean;
+    getAttr(key: string): string | undefined;
+    getChilren(): nestedTree<DisplayComponent>;
+}

package/lib/types/abstract/parser/moduleInputObject.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class moduleInputObject {
+    constructor(attrObj, children) {
+        this.paramMap = new Map();
+        Object.keys(attrObj).forEach(i => {
+            this.paramMap.set(i, attrObj[i]);
+        });
+        this.chilren = children;
+    }
+    hasAttr(key) {
+        return this.paramMap.has(key) && this.paramMap.get(key) != undefined;
+    }
+    getAttr(key) {
+        return this.paramMap.get(key);
+    }
+    getChilren() {
+        return this.chilren;
+    }
+}
+exports.default = moduleInputObject;

package/lib/types/abstract/parser/options.d.ts

@@ -0,0 +1,31 @@
+import type { dry_card } from "../../../data/systemRegistry";
+export declare enum parseMode {
+    "gameplay" = 0,
+    "catalog" = 1,
+    "reprogram" = 2,
+    "info" = 3,
+    "debug" = 4
+}
+declare class parseOptions {
+    flat_parse: boolean;
+    mode: parseMode;
+    cardData?: dry_card;
+    inputNumber: number[];
+    inputString: string[];
+    constructor(mode: parseMode, input: (number | string)[], flat_parse?: boolean, card?: dry_card);
+}
+declare class loadOptions {
+    modulesInUse: string[];
+    modulePath: string;
+    constructor(modulePath: string, modules?: string[]);
+}
+declare const lib_parse_option: {
+    preserveComments: boolean;
+    preserveXmlDeclaration: boolean;
+    preserveDocumentType: boolean;
+    ignoreUndefinedEntities: boolean;
+    includeOffsets: boolean;
+    sortAttributes: boolean;
+    preserveCdata: boolean;
+};
+export { parseOptions, loadOptions, lib_parse_option };

package/lib/types/abstract/parser/options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lib_parse_option = exports.loadOptions = exports.parseOptions = exports.parseMode = void 0;
+//TODO : integrate cardData and effectData into this
+var parseMode;
+(function (parseMode) {
+    parseMode[parseMode["gameplay"] = 0] = "gameplay";
+    parseMode[parseMode["catalog"] = 1] = "catalog";
+    parseMode[parseMode["reprogram"] = 2] = "reprogram";
+    parseMode[parseMode["info"] = 3] = "info";
+    parseMode[parseMode["debug"] = 4] = "debug";
+})(parseMode || (exports.parseMode = parseMode = {}));
+class parseOptions {
+    constructor(mode, input, flat_parse = false, card) {
+        this.flat_parse = flat_parse;
+        this.mode = mode;
+        this.cardData = card;
+        this.inputNumber = [];
+        this.inputString = [];
+        input.forEach(i => {
+            if (typeof i == "string")
+                this.inputString.push(i);
+            else
+                this.inputNumber.push(i);
+        });
+    }
+}
+exports.parseOptions = parseOptions;
+class loadOptions {
+    constructor(modulePath, modules = []) {
+        this.modulePath = modulePath;
+        this.modulesInUse = modules;
+    }
+}
+exports.loadOptions = loadOptions;
+const lib_parse_option = {
+    preserveComments: false,
+    preserveXmlDeclaration: false,
+    preserveDocumentType: false,
+    ignoreUndefinedEntities: false,
+    includeOffsets: true,
+    sortAttributes: false,
+    preserveCdata: false,
+};
+exports.lib_parse_option = lib_parse_option;

package/lib/types/abstract/serializedGameComponents/Gamestate.d.ts

@@ -0,0 +1,46 @@
+import type { partitionData } from "../../../data/cardRegistry";
+import type { deckRegistry } from "../../../data/deckRegistry";
+import type effectTypeRegistry from "../../../data/effectTypeRegistry";
+import type { operatorID } from "../../../data/operatorRegistry";
+import type { subtypeName } from "../../../data/subtypeRegistry";
+import type { playerTypeID } from "../../../data/zoneRegistry";
+export declare class Serialized_effect {
+    dataID: string;
+    typeID: keyof typeof effectTypeRegistry;
+    subTypeIDs: subtypeName[];
+    displayID_default: string;
+    attr: Record<string, number>;
+    constructor(dataID: string, typeID: keyof typeof effectTypeRegistry, subTypeIDs: subtypeName[], displayID_default: string | undefined, //undefined means use effectID
+    attr: Map<string, any>);
+}
+export declare class SerializedCard {
+    dataID: string;
+    variants: string[];
+    effects: Serialized_effect[];
+    statusEffects: Serialized_effect[];
+    partitions: partitionData[];
+    attr: Record<string, any>;
+    constructor(dataID: string, variants: string[] | undefined, effects: Serialized_effect[], statusEffects: Serialized_effect[], partitions: partitionData[], attr: Map<string, any>);
+}
+export declare class SerializedZone {
+    classID: string;
+    dataID: string;
+    cardArr: (SerializedCard | undefined)[];
+    types: number[];
+    attr: Record<string, any>;
+    constructor(classID: string, dataID: string, cardArr: (SerializedCard | undefined)[], types: number[], attr: Map<string, any>);
+}
+export declare class SerializedPlayer {
+    pType: playerTypeID;
+    heart: number;
+    operator: operatorID;
+    deckName?: deckRegistry | undefined;
+    constructor(pType: playerTypeID, heart: number, operator: operatorID, deckName?: deckRegistry | undefined);
+}
+export declare class SerializedSystem {
+    players: SerializedPlayer[];
+    zones: SerializedZone[];
+    turn: number;
+    wave: number;
+    constructor(players: SerializedPlayer[], zones: SerializedZone[], turn: number, wave: number);
+}

package/lib/types/abstract/serializedGameComponents/Gamestate.js

@@ -0,0 +1,70 @@
+"use strict";
+//For saving / loading
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedSystem = exports.SerializedPlayer = exports.SerializedZone = exports.SerializedCard = exports.Serialized_effect = void 0;
+class Serialized_effect {
+    constructor(
+    // public id : string, //generated again
+    dataID, typeID, subTypeIDs, displayID_default = dataID, //undefined means use effectID
+    attr) {
+        this.dataID = dataID;
+        this.typeID = typeID;
+        this.subTypeIDs = subTypeIDs;
+        this.displayID_default = displayID_default;
+        this.attr = {};
+        attr.forEach((val, key) => {
+            if (typeof val === "number")
+                this.attr[key] = val;
+        });
+    }
+}
+exports.Serialized_effect = Serialized_effect;
+class SerializedCard {
+    constructor(
+    // public id : string, //generated again
+    dataID, variants = [], 
+    //I have to save partition too ahhh
+    effects, statusEffects, partitions, attr) {
+        this.dataID = dataID;
+        this.variants = variants;
+        this.effects = effects;
+        this.statusEffects = statusEffects;
+        this.partitions = partitions;
+        this.attr = {};
+        attr.forEach((val, key) => {
+            this.attr[key] = val; //Hopefully serializable
+        });
+    }
+}
+exports.SerializedCard = SerializedCard;
+class SerializedZone {
+    constructor(classID, dataID, cardArr, types, attr) {
+        this.classID = classID;
+        this.dataID = dataID;
+        this.cardArr = cardArr;
+        this.types = types;
+        this.attr = {};
+        attr.forEach((val, key) => {
+            this.attr[key] = val; //Hopefully serializable
+        });
+    }
+}
+exports.SerializedZone = SerializedZone;
+class SerializedPlayer {
+    constructor(pType, heart, operator, deckName) {
+        this.pType = pType;
+        this.heart = heart;
+        this.operator = operator;
+        this.deckName = deckName;
+    }
+}
+exports.SerializedPlayer = SerializedPlayer;
+class SerializedSystem {
+    constructor(players, zones, turn, wave) {
+        this.players = players;
+        this.zones = zones;
+        this.turn = turn;
+        this.wave = wave;
+    }
+}
+exports.SerializedSystem = SerializedSystem;

package/lib/types/abstract/serializedGameComponents/Localized.d.ts

@@ -0,0 +1,69 @@
+import type { rarityRegistry } from "../../../data/rarityRegistry";
+import type { playerTypeID, zoneRegistry } from "../../../data/zoneRegistry";
+import type { DisplayComponent } from "../parser";
+type LocalizedString = DisplayComponent[];
+export declare class LocalizedEffect {
+    id: number;
+    text: LocalizedString;
+    type: LocalizedString;
+    subtypes: LocalizedString[];
+    typeDesc?: LocalizedString | undefined;
+    subtypesDesc?: (LocalizedString | undefined)[] | undefined;
+    constructor(id: number, //pid technically
+    text: LocalizedString, type: LocalizedString, subtypes: LocalizedString[], typeDesc?: LocalizedString | undefined, subtypesDesc?: (LocalizedString | undefined)[] | undefined);
+}
+export declare class LocalizedCard {
+    id: string;
+    name: LocalizedString;
+    extensions: LocalizedString[];
+    effects: LocalizedEffect[];
+    statusEffects: LocalizedEffect[];
+    zoneID: number;
+    pos: number[];
+    atk: number;
+    hp: number;
+    maxAtk: number;
+    maxHp: number;
+    level: number;
+    rarity: rarityRegistry;
+    rarityName: LocalizedString;
+    archtype: LocalizedString[];
+    constructor(id: string, name: LocalizedString, extensions: LocalizedString[], effects: LocalizedEffect[], statusEffects: LocalizedEffect[], zoneID: number, pos: number[], atk: number, //display stat
+    hp: number, //display stat
+    maxAtk: number, maxHp: number, level: number, rarity: rarityRegistry, rarityName: LocalizedString, archtype: LocalizedString[]);
+}
+export declare class LocalizedZone {
+    id: number;
+    pid: number;
+    type: zoneRegistry[];
+    typeName: LocalizedString[];
+    name: LocalizedString;
+    cards: (LocalizedCard | undefined)[];
+    shape: number[];
+    constructor(id: number, pid: number, type: zoneRegistry[], typeName: LocalizedString[], name: LocalizedString, cards: (LocalizedCard | undefined)[], shape: number[]);
+}
+export declare class LocalizedAction {
+    id: number;
+    name: LocalizedString;
+    constructor(id: number, name: LocalizedString);
+}
+export declare class LocalizedPlayer {
+    id: number;
+    type: playerTypeID;
+    pType: LocalizedString;
+    heart: number;
+    maxHeart: number;
+    operator: LocalizedString;
+    deckName: LocalizedString;
+    constructor(id: number, type: playerTypeID, pType: LocalizedString, heart: number, maxHeart: number, operator: LocalizedString, deckName: LocalizedString);
+}
+export declare class LocalizedSystem {
+    players: LocalizedPlayer[];
+    zones: LocalizedZone[];
+    action: LocalizedAction;
+    phase: number;
+    turn: number;
+    wave: number;
+    constructor(players: LocalizedPlayer[], zones: LocalizedZone[], action: LocalizedAction, phase: number, turn: number, wave: number);
+}
+export {};

package/lib/types/abstract/serializedGameComponents/Localized.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizedSystem = exports.LocalizedPlayer = exports.LocalizedAction = exports.LocalizedZone = exports.LocalizedCard = exports.LocalizedEffect = void 0;
+class LocalizedEffect {
+    constructor(id, //pid technically
+    text, type, subtypes, typeDesc, subtypesDesc) {
+        this.id = id;
+        this.text = text;
+        this.type = type;
+        this.subtypes = subtypes;
+        this.typeDesc = typeDesc;
+        this.subtypesDesc = subtypesDesc;
+    }
+}
+exports.LocalizedEffect = LocalizedEffect;
+class LocalizedCard {
+    constructor(id, name, extensions, effects, statusEffects, zoneID, pos, 
+    //stat
+    atk, //display stat
+    hp, //display stat
+    maxAtk, maxHp, level, rarity, rarityName, archtype) {
+        this.id = id;
+        this.name = name;
+        this.extensions = extensions;
+        this.effects = effects;
+        this.statusEffects = statusEffects;
+        this.zoneID = zoneID;
+        this.pos = pos;
+        this.atk = atk;
+        this.hp = hp;
+        this.maxAtk = maxAtk;
+        this.maxHp = maxHp;
+        this.level = level;
+        this.rarity = rarity;
+        this.rarityName = rarityName;
+        this.archtype = archtype;
+    }
+}
+exports.LocalizedCard = LocalizedCard;
+class LocalizedZone {
+    constructor(id, pid, type, typeName, name, cards, shape) {
+        this.id = id;
+        this.pid = pid;
+        this.type = type;
+        this.typeName = typeName;
+        this.name = name;
+        this.cards = cards;
+        this.shape = shape;
+        while (cards.length && cards.at(-1) === undefined)
+            cards.splice(-1, 1);
+        this.cards = cards;
+    }
+}
+exports.LocalizedZone = LocalizedZone;
+class LocalizedAction {
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+}
+exports.LocalizedAction = LocalizedAction;
+class LocalizedPlayer {
+    constructor(id, type, pType, heart, maxHeart, operator, deckName) {
+        this.id = id;
+        this.type = type;
+        this.pType = pType;
+        this.heart = heart;
+        this.maxHeart = maxHeart;
+        this.operator = operator;
+        this.deckName = deckName;
+    }
+}
+exports.LocalizedPlayer = LocalizedPlayer;
+class LocalizedSystem {
+    constructor(players, zones, action, phase, turn, wave) {
+        this.players = players;
+        this.zones = zones;
+        this.action = action;
+        this.phase = phase;
+        this.turn = turn;
+        this.wave = wave;
+    }
+}
+exports.LocalizedSystem = LocalizedSystem;

package/lib/types/defaultZones/ability.d.ts

@@ -0,0 +1,10 @@
+import Card from "../abstract/gameComponents/card";
+import zone_stack from "../abstract/gameComponents/zone_stackBased";
+import res from "../abstract/generics/universalResponse";
+declare class Ability extends zone_stack {
+    get maxCoolDown(): number;
+    set maxCoolDown(newVal: number);
+    currentCoolDown: number;
+    remove(c: Card): res;
+}
+export default Ability;

package/lib/types/defaultZones/ability.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const zone_stackBased_1 = __importDefault(require("../abstract/gameComponents/zone_stackBased"));
+class Ability extends zone_stackBased_1.default {
+    constructor() {
+        //TODO : figure out wtf this does
+        //currently doing nothing but storing the ability card
+        super(...arguments);
+        this.currentCoolDown = this.maxCoolDown;
+    }
+    get maxCoolDown() { var _a; return (_a = this.attr.get("maxCoolDown")) !== null && _a !== void 0 ? _a : -1; }
+    ;
+    set maxCoolDown(newVal) { this.attr.set("maxCoolDown", newVal); }
+    ;
+    remove(c) {
+        return [undefined, []];
+    }
+}
+exports.default = Ability;