qpremake 1.5.1

package/lib/data/zoneRegistry.d.ts

@@ -0,0 +1,43 @@
+type zoneData_fixxed_entries = {
+    priority: number;
+    posBound: number[];
+    minCapacity: number;
+    attriutesArr: zoneAttributes[];
+    instancedFor: playerTypeID[];
+    types?: number[];
+};
+type zoneData_variable_entries = {
+    [key: string]: string | number | boolean;
+};
+type zoneData = (zoneData_fixxed_entries) | (zoneData_fixxed_entries & zoneData_variable_entries);
+declare enum zoneRegistry {
+    z_system = 0,
+    z_drop = 1,
+    z_void = 2,
+    z_deck = 3,
+    z_field = 4,
+    z_grave = 5,
+    z_hand = 6,
+    z_storage = 7,
+    z_ability = 8
+}
+declare enum zoneAttributes {
+    canReorderSelf = 0,
+    canMoveFrom = 1,
+    canMoveTo = 2,
+    moveToNeedPosition = 3
+}
+type zoneName = keyof typeof zoneRegistry;
+type zoneID = (typeof zoneRegistry)[zoneName];
+declare enum playerTypeID {
+    player = 1,
+    enemy = 2
+}
+type playerTypeName = keyof typeof playerTypeID;
+declare const playerOppositeMap: {
+    readonly player: readonly [playerTypeID.enemy];
+    readonly enemy: readonly [playerTypeID.player];
+};
+declare const zoneDataRegistry: Record<zoneName, zoneData>;
+export default zoneDataRegistry;
+export { zoneAttributes, playerTypeID, playerTypeName, playerOppositeMap, zoneData, zoneRegistry, zoneName, zoneID, zoneDataRegistry };

package/lib/data/zoneRegistry.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoneDataRegistry = exports.zoneRegistry = exports.playerOppositeMap = exports.playerTypeID = exports.zoneAttributes = void 0;
+//dataID lookup
+var zoneRegistry;
+(function (zoneRegistry) {
+    zoneRegistry[zoneRegistry["z_system"] = 0] = "z_system";
+    zoneRegistry[zoneRegistry["z_drop"] = 1] = "z_drop";
+    zoneRegistry[zoneRegistry["z_void"] = 2] = "z_void";
+    zoneRegistry[zoneRegistry["z_deck"] = 3] = "z_deck";
+    zoneRegistry[zoneRegistry["z_field"] = 4] = "z_field";
+    zoneRegistry[zoneRegistry["z_grave"] = 5] = "z_grave";
+    zoneRegistry[zoneRegistry["z_hand"] = 6] = "z_hand";
+    zoneRegistry[zoneRegistry["z_storage"] = 7] = "z_storage";
+    zoneRegistry[zoneRegistry["z_ability"] = 8] = "z_ability";
+})(zoneRegistry || (exports.zoneRegistry = zoneRegistry = {}));
+//booleans basically 
+var zoneAttributes;
+(function (zoneAttributes) {
+    zoneAttributes[zoneAttributes["canReorderSelf"] = 0] = "canReorderSelf";
+    zoneAttributes[zoneAttributes["canMoveFrom"] = 1] = "canMoveFrom";
+    zoneAttributes[zoneAttributes["canMoveTo"] = 2] = "canMoveTo";
+    zoneAttributes[zoneAttributes["moveToNeedPosition"] = 3] = "moveToNeedPosition";
+})(zoneAttributes || (exports.zoneAttributes = zoneAttributes = {}));
+var playerTypeID;
+(function (playerTypeID) {
+    playerTypeID[playerTypeID["player"] = 1] = "player";
+    playerTypeID[playerTypeID["enemy"] = 2] = "enemy";
+})(playerTypeID || (exports.playerTypeID = playerTypeID = {}));
+const playerOppositeMap = {
+    player: [playerTypeID.enemy],
+    enemy: [playerTypeID.player],
+};
+exports.playerOppositeMap = playerOppositeMap;
+//priority high = act first
+const zoneDataRegistry = {
+    z_system: {
+        priority: Infinity,
+        posBound: [],
+        minCapacity: -Infinity,
+        attriutesArr: [],
+        instancedFor: [],
+        startThreat: 0,
+        maxThreat: 20,
+        clearThreatWhenBurn: false,
+    },
+    z_drop: {
+        priority: Infinity,
+        posBound: [Infinity],
+        minCapacity: 0,
+        attriutesArr: [
+            zoneAttributes.canReorderSelf,
+            zoneAttributes.canMoveTo,
+            zoneAttributes.canMoveFrom,
+        ],
+        instancedFor: [],
+    },
+    z_deck: {
+        priority: 1,
+        posBound: [Infinity],
+        minCapacity: 0,
+        attriutesArr: [
+            zoneAttributes.canReorderSelf,
+            zoneAttributes.canMoveTo,
+            zoneAttributes.canMoveFrom,
+            zoneAttributes.moveToNeedPosition,
+        ],
+        instancedFor: [
+            playerTypeID.player
+        ],
+        startCoolDown: 10,
+        maxCooldown: 10,
+        maxLoad: 20,
+        minLoad: 1,
+    },
+    z_storage: {
+        priority: 0,
+        posBound: [Infinity],
+        minCapacity: 0,
+        attriutesArr: [
+            zoneAttributes.canMoveFrom,
+        ],
+        instancedFor: [
+            playerTypeID.player
+        ],
+    },
+    z_grave: {
+        priority: 2,
+        posBound: [Infinity],
+        minCapacity: 0,
+        attriutesArr: [
+            zoneAttributes.canMoveTo,
+            zoneAttributes.canMoveFrom,
+        ],
+        instancedFor: [
+            playerTypeID.player,
+            playerTypeID.enemy,
+        ]
+    },
+    z_hand: {
+        priority: 4,
+        posBound: [7],
+        minCapacity: 0,
+        attriutesArr: [
+            zoneAttributes.canReorderSelf,
+            zoneAttributes.canMoveFrom,
+            zoneAttributes.canMoveTo,
+            zoneAttributes.moveToNeedPosition,
+        ],
+        instancedFor: [
+            playerTypeID.player,
+        ],
+    },
+    z_field: {
+        priority: 5,
+        posBound: [5, 2],
+        canReorderSelf: true,
+        canMoveTo: true,
+        canMoveFrom: true,
+        moveToNeedPosition: true,
+        minCapacity: 0,
+        attriutesArr: [
+            zoneAttributes.canReorderSelf,
+            zoneAttributes.canMoveFrom,
+            zoneAttributes.canMoveTo,
+            zoneAttributes.moveToNeedPosition,
+        ],
+        instancedFor: [
+            playerTypeID.player,
+            playerTypeID.enemy,
+        ]
+    },
+    z_ability: {
+        priority: -1,
+        posBound: [1],
+        canMoveFrom: true,
+        minCapacity: 0,
+        attriutesArr: [],
+        instancedFor: [
+            playerTypeID.player
+        ],
+        maxCoolDown: 10,
+    },
+    z_void: {
+        //void is temporary card storage when cards are voided
+        //or "dissapear"
+        priority: -2,
+        posBound: [Infinity],
+        attriutesArr: [
+            zoneAttributes.canMoveTo,
+        ],
+        instancedFor: [],
+        minCapacity: 0,
+    }
+};
+exports.zoneDataRegistry = zoneDataRegistry;
+exports.default = zoneDataRegistry;

package/lib/effectTextParser/index.d.ts

@@ -0,0 +1,42 @@
+import { DisplayComponent, parseOptions, loadOptions } from '../types/abstract/parser';
+import type { nestedTree } from '../types/misc';
+export default class Parser {
+    private loaded;
+    private moduleArr;
+    private moduleMap;
+    load(l: loadOptions): Promise<void>;
+    private parse_internal_lib_level;
+    private parse_internal_loader_level_node;
+    private parse_internal_loader_level;
+    private recur_flat_tree;
+    private equationRegex;
+    private elementRegex;
+    private operationList_infix;
+    private operationList_prefix;
+    private preparse_regs;
+    private preParseXML;
+    private applyReg1;
+    parse(XML: string, o: parseOptions): nestedTree<DisplayComponent>;
+}
+export { parseOptions, loadOptions };
+/**
+ * Added shorthands:
+ * =abcABC... : prints out the value of a, b, c, A, B, C...
+ * = a + 1 + A : do the expression
+/*
+USAGE
+
+async function main() {
+    let p = new parser()
+    await p.load(new loadOptions(undefined, ["qpOriginal"]))
+
+    let str = `test numeric: <if type = "number"><numeric> a + b > c </><string> A + B </><string> C + D </></>`
+    let str2 = `<string> A + B </><string> C + D </>`
+    let str3 = `<string> A + " I am a cat "</>`
+    let option = new parseOptions(mode.gameplay, "", [3.115926, -5, 50, "cat", "dog", "horse", "house"], false)
+    console.log(`parsing test1: `, p.parse(str, option))
+    console.log(`parsing test2: `,p.parse(str2, option))
+    console.log(`parsing test3: `,p.parse(str3, option))
+    //console.log("debugMode: ", JSON.stringify(p.debug_parse(str), null, 4))
+}
+*/ 

package/lib/effectTextParser/index.js

@@ -0,0 +1,316 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOptions = exports.parseOptions = void 0;
+const parse_xml_1 = require("@rgrove/parse-xml");
+const parse_xml_2 = require("@rgrove/parse-xml");
+const parser_1 = require("../types/abstract/parser");
+Object.defineProperty(exports, "parseOptions", { enumerable: true, get: function () { return parser_1.parseOptions; } });
+Object.defineProperty(exports, "loadOptions", { enumerable: true, get: function () { return parser_1.loadOptions; } });
+class Parser {
+    constructor() {
+        this.loaded = false;
+        this.moduleArr = [];
+        this.moduleMap = new Map();
+        this.elementRegex = /[A-Za-z0-9]|".*"/;
+        this.operationList_infix = [
+            "==", "===",
+            "!=", "!==",
+            ">", "<",
+            ">=", "<=",
+            "&&", "&",
+            "||", "|",
+            ">>", "<<",
+            "++",
+            "+", "-", "*", "/",
+            ".."
+        ];
+        this.operationList_prefix = [
+            "!", "+", "-"
+        ];
+        this.preparse_regs = [
+            /=\s*([A-Za-z0-9]+)\s*;?/g, //=ABC...
+            this.equationRegex(this.operationList_prefix, this.operationList_infix, [], this.elementRegex, "=", ";")
+        ];
+    }
+    //[module index, command index]
+    //
+    load(l) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let path = l.modulePath;
+            if (!path.endsWith("/"))
+                path += "/";
+            // console.log(`load triggered, ab to load ${l.modulesInUse.length} modules`)
+            for (let x = 0; x < l.modulesInUse.length; x++) {
+                let i = l.modulesInUse[x];
+                //start dynamic importing
+                let moduleClass = yield Promise.resolve(`${path + i}`).then(s => __importStar(require(s)));
+                if (!moduleClass || !moduleClass.default) {
+                    console.warn(`WARN: Cannot import module ${i} in path ${path + i}`);
+                }
+                else {
+                    let moduleInstance = new moduleClass.default();
+                    //test malformed module
+                    if (!(moduleInstance instanceof parser_1.ParserModule)) {
+                        console.warn(`WARN: file ${path + i} is not a module, skipped`);
+                    }
+                    else {
+                        if (moduleInstance.requiredAttr.length != moduleInstance.cmdName.length) {
+                            console.warn(`WARN: module ${i} is malformed: paramName and cmdName length does not matched up, auto filled with empty arrays`);
+                            while (moduleInstance.cmdName.length > moduleInstance.requiredAttr.length) {
+                                moduleInstance.requiredAttr.push([]);
+                            }
+                        }
+                        let k = this.moduleArr.length;
+                        this.moduleArr.push(moduleInstance);
+                        moduleInstance.cmdName.forEach((n, index) => {
+                            //if repeated keys appear, take the latter
+                            if (this.moduleMap.has(n)) {
+                                let [oldModuleNumber, _] = this.moduleMap.get(n);
+                                let oldName = l.modulesInUse[oldModuleNumber];
+                                if (oldModuleNumber == k) {
+                                    console.warn(`WARN: Module ${oldName} has duplicate command : ${n}`);
+                                }
+                                else
+                                    console.warn(`WARN: Repeated commands in multiple modules found, cmd = ${n}, originally from ${oldName}, currently override to use from module ${i}`);
+                            }
+                            this.moduleMap.set(n, [k, index]);
+                            // console.log(`loaded cmd ${n} from module ${i}`)
+                        });
+                    }
+                }
+            }
+            this.loaded = true;
+        });
+    }
+    parse_internal_lib_level(str, inRecur = false, escapedCharLimit = str.length) {
+        if (!inRecur) {
+            str = `<document>${str}</document>`; //if i dont do this, it doesnt work
+        }
+        try {
+            //the lib wraps everything in a layer so we need to extract that layer
+            return (0, parse_xml_1.parseXml)(str, parser_1.lib_parse_option).children[0];
+        }
+        catch (err) {
+            if (err.message.startsWith("Missing end tag")) {
+                let temp = err.message.indexOf("(line");
+                if (temp == -1)
+                    throw err;
+                let cTag = err.message.slice(28, temp - 1);
+                let pre = str.slice(0, err.pos);
+                let post = str.slice(err.pos + 1);
+                const properClose = `</${cTag}>`;
+                const properOpen = `<${cTag}>`;
+                //situation patchfix 1: allowing </> as a universal end tag
+                //by repllacing </> with the proper close tag 
+                const flag1 = str.slice(err.pos, err.pos + 3) === "</>";
+                if (flag1) {
+                    post = str.slice(err.pos + 3);
+                    return this.parse_internal_lib_level(pre + properClose + post, true, escapedCharLimit); //reparse
+                }
+                const errorChar = str[err.pos];
+                if (errorChar) {
+                    const escapedChar = `&#${errorChar.charCodeAt(0)};`;
+                    //situation patchfix 2: escape the character that fails to parse
+                    //try replacing the problematic character with its XML entity
+                    if (escapedCharLimit <= 0)
+                        throw err;
+                    return this.parse_internal_lib_level(pre + escapedChar + post, true, escapedCharLimit - 1);
+                }
+            }
+            throw err;
+        }
+    }
+    parse_internal_loader_level_node(originalXML, tree, o, children) {
+        const cmd = tree.name;
+        if (this.moduleMap.has(cmd)) {
+            const [moduleIndex, cmdIndex] = this.moduleMap.get(cmd);
+            const module = this.moduleArr[moduleIndex];
+            const inputObj = module.generateInputObj(cmdIndex, tree.attributes, children);
+            if (!inputObj) {
+                //incorrect input
+                const errMes = `Failed to parse input for module ${cmd}, tried to parse attributes: ${JSON.stringify(tree.attributes, null, 0)}, required attributes = ${JSON.stringify(module.requiredAttr[cmdIndex], null, 0)}, reverting to text node`;
+                //console.warn(errMes)
+                return [new parser_1.TextComponent(tree.text, errMes, cmd, tree.text)];
+            }
+            return module.evaluate(cmd, inputObj, o, tree.text);
+        }
+        else {
+            const errMes = `WARN: unknown module, tried to invoke ${cmd}, reverting to a text node`;
+            // console.warn(errMes)
+            return [new parser_1.TextComponent(tree.text, errMes, cmd, tree.text)];
+        }
+    }
+    parse_internal_loader_level(originalXML, tree, o) {
+        if (tree instanceof parse_xml_2.XmlProcessingInstruction) {
+            //undefined behavior?
+            //idk what this shit is???
+            const errMes = `WARN: XML processing instruction not supported (trying to parse instuction name = ${tree.name}, content = ${tree.content}), reverting to text node`;
+            // console.warn(errMes)
+            return [new parser_1.TextComponent(originalXML.slice(tree.start, tree.end), errMes, undefined, originalXML.slice(tree.start, tree.end))];
+        }
+        else {
+            if (!tree.children || !tree.children.length) {
+                //base case
+                if (tree.type == "text") {
+                    return [new parser_1.TextComponent(tree.text, undefined, undefined, tree.text)];
+                }
+                return this.parse_internal_loader_level_node(originalXML, tree, o, []);
+            }
+            const deeperParse = tree.children.map((i) => this.parse_internal_loader_level(originalXML, i, o));
+            return this.parse_internal_loader_level_node(originalXML, tree, o, deeperParse);
+        }
+    }
+    recur_flat_tree(tree) {
+        let r = [];
+        tree.forEach(i => {
+            if (i instanceof parser_1.DisplayComponent)
+                r.push(i);
+            else
+                r.push(...this.recur_flat_tree(i));
+        });
+        return r;
+    }
+    equationRegex(prefixOperator, inFixOperator, postFixOperator, elementRegex, prefix, postfix) {
+        const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        // Operators
+        const preOps = prefixOperator.length ? `(?:${prefixOperator.map(escape).join("|")})?` : "";
+        const inOps = inFixOperator.length ? `(?:${inFixOperator.map(escape).join("|")})` : "";
+        const postOps = postFixOperator.length ? `(?:${postFixOperator.map(escape).join("|")})?` : "";
+        // Base element core
+        const elemCore = elementRegex.source;
+        // Bracketed sub-expressions
+        const bracketed = [
+            `\\(${elemCore}(?:\\s*${inOps}\\s*${elemCore})*\\)`,
+            `\\[${elemCore}(?:\\s*${inOps}\\s*${elemCore})*\\]`,
+            `\\{${elemCore}(?:\\s*${inOps}\\s*${elemCore})*\\}`
+        ].join("|");
+        // Base element (prefix/postfix supported)
+        const elem = `${preOps}(?:${elemCore}|${bracketed})${postOps}`;
+        // Ternary expression form
+        const ternary = `${elem}\\s*\\?\\s*${elem}\\s*:\\s*${elem}`;
+        // Combined atomic unit: an element or a ternary expression
+        const atomic = `(?:${ternary}|${elem})`;
+        // Equation body (chain of atomic units with infix ops)
+        const body = `${atomic}(?:\\s*${inOps}\\s*${atomic})*`;
+        // Boundaries
+        const start = `(?:${escape(prefix)})`;
+        const end = postfix ? `(?:${escape(postfix)})` : "";
+        return new RegExp(`${start}\\s*(${body})\\s*${end}`, "g");
+    }
+    preParseXML(XML) {
+        const [reg1, reg2] = this.preparse_regs;
+        const segments = []; // ordered pieces of the final output
+        let lastIndex = 0;
+        // Scan for all reg2 matches
+        XML.replace(reg2, (match, group, offset) => {
+            // Unprotected text before this reg2 match
+            if (offset > lastIndex) {
+                const chunk = XML.slice(lastIndex, offset);
+                segments.push(this.applyReg1(chunk, reg1));
+            }
+            segments.push(`<expr> ${group} </>`);
+            lastIndex = offset + match.length;
+            return ""; // not used
+        });
+        // Remainder after last reg2 match
+        if (lastIndex < XML.length) {
+            const chunk = XML.slice(lastIndex);
+            segments.push(this.applyReg1(chunk, reg1));
+        }
+        return segments.join("");
+    }
+    // Apply reg1 only to normal text (NOT inside reg2 results)
+    applyReg1(text, reg1) {
+        return text.replace(reg1, (_, str) => str
+            .split("")
+            .map((c) => `<expr> ${c} </>`)
+            .join(""));
+    }
+    parse(XML, o) {
+        if (!this.loaded) {
+            throw `Parser did not finish loading modules, call load() first`;
+        }
+        //replace shorthands with actual tags
+        //=abc...
+        XML = this.preParseXML(XML);
+        let tree;
+        try {
+            tree = this.parse_internal_lib_level(XML);
+        }
+        catch (e) {
+            return [new parser_1.TextComponent(XML, "Failed to parse XML")];
+        }
+        if (!tree.children || !tree.children.length)
+            return [];
+        const parsedTree = tree.children.map(i => this.parse_internal_loader_level(XML, i, o));
+        if (o.flat_parse) {
+            return this.recur_flat_tree(parsedTree);
+        }
+        else
+            return parsedTree;
+    }
+}
+exports.default = Parser;
+/**
+ * Added shorthands:
+ * =abcABC... : prints out the value of a, b, c, A, B, C...
+ * = a + 1 + A : do the expression
+/*
+USAGE
+
+async function main() {
+    let p = new parser()
+    await p.load(new loadOptions(undefined, ["qpOriginal"]))
+
+    let str = `test numeric: <if type = "number"><numeric> a + b > c </><string> A + B </><string> C + D </></>`
+    let str2 = `<string> A + B </><string> C + D </>`
+    let str3 = `<string> A + " I am a cat "</>`
+    let option = new parseOptions(mode.gameplay, "", [3.115926, -5, 50, "cat", "dog", "horse", "house"], false)
+    console.log(`parsing test1: `, p.parse(str, option))
+    console.log(`parsing test2: `,p.parse(str2, option))
+    console.log(`parsing test3: `,p.parse(str3, option))
+    //console.log("debugMode: ", JSON.stringify(p.debug_parse(str), null, 4))
+}
+*/ 

package/lib/global/index.d.ts

@@ -0,0 +1,8 @@
+import utils from "../utils";
+declare global {
+    var Utils: typeof utils;
+}
+declare const globalLoader: {
+    load(): void;
+};
+export default globalLoader;

package/lib/global/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = __importDefault(require("../utils"));
+const globalLoader = {
+    load() {
+        globalThis.Utils = utils_1.default;
+    }
+};
+exports.default = globalLoader;