qpremake 1.5.2 → 1.6.3

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

@@ -1,95 +0,0 @@
-import { dry_position, inputData_pos, inputData_standard, inputData_str, inputDataSpecific, inputType, type dry_card, type dry_effect, type dry_effectSubType, type dry_system, type dry_zone, type inputData, type inputData_bool, type inputData_card, type inputData_effect, type inputData_num, type inputData_player, type inputData_subtype, type inputData_zone } from "../../data/systemRegistry";
-import { Action } from "./actionGenrator";
-import { validSetFormat } from "../../data/systemRegistry";
-import { Tuple_any } from "../../types/misc";
-/**
- * Merge with signature example:
- * A has input [X, Y, Z, K]
- * B has input [X, Y, K, L, Z]
- *
- * Merging these will yield C having input [...A, ...exclude B from A, stop at first not match in B]
- * the previous example will results to [X, Y, Z, K, L, Z]
- * [X, Y, Z, K] from A
- * and [L, Z] from B after filling A's input into B as best as we can
- * well..not rlly but I do not want to recur try to apply every input every time we apply new inputs
- *
- * oh also apply returns, please make sure to overwrite the val after apply
- */
-export declare const inputFormRegistry: {
-    readonly zone: (s: dry_system, z: dry_zone) => inputData_zone;
-    readonly card: (s: dry_system, c: dry_card) => inputData_card;
-    readonly effect: (s: dry_system, c: dry_card, e: dry_effect) => inputData_effect;
-    readonly subtype: (s: dry_system, c: dry_card, e: dry_effect, st: dry_effectSubType) => inputData_subtype;
-    readonly player: (s: dry_system, pid: number) => inputData_player;
-    readonly pos: (s: dry_system, pos: dry_position) => inputData_pos;
-    readonly num: (num: number) => inputData_num;
-    readonly str: (str: string) => inputData_str;
-    readonly bool: (bool: boolean) => inputData_bool;
-};
-export type inputRequester_finalized<T_accu extends Exclude<inputData[], []>> = {
-    next: () => T_accu;
-};
-export declare class inputRequester<K extends inputType = inputType, //initial type, for inference, useless after constructor is called
-T extends inputData[] = [inputDataSpecific<K>], //inputs tuple yet to apply, [] means finished
-T_accumulate extends Exclude<inputData[], []> = T, //inputs tuple as a whole, inference at first
-T_data_last extends inputData = inputDataSpecific<K>, //last entry of the array, deprecated
-T_head extends inputData = T extends [infer head, ...any[]] ? head : inputData, //inference
-T_tail extends inputData[] = T extends [any, ...infer tail] ? tail : inputData[]> {
-    protected __inner_res: inputData[];
-    protected __func_arr: ((s: dry_system, prev: inputData[]) => Exclude<inputData[], []> | validSetFormat)[];
-    protected __curr: validSetFormat | undefined;
-    protected __queue: inputRequester<any, inputData[], inputData[], any, any>[];
-    protected __valid_flag: boolean;
-    protected __do_pre_fill_when_merge: boolean;
-    protected __len: number;
-    protected __cursor_f_arr: number;
-    protected reserved_inner_res: inputData[];
-    emplaceReserve(): void;
-    cache: inputRequestCache<T_accumulate>;
-    updateValidFlag(set: inputData[]): void;
-    get len(): number;
-    constructor(type: K, validSet?: Exclude<inputDataSpecific<K>[], []>);
-    hasInput(): this is this;
-    private verify;
-    private isCurrentInputAllows;
-    protected copyToNext(next: inputRequester<any, inputData[], inputData[], any, any>): void;
-    apply(s: dry_system, input: T_head): T_tail extends [] ? inputRequester_finalized<T_accumulate> : inputRequester<inputType, T_tail, T_accumulate, T_data_last>;
-    applyMultiple(s: dry_system, inputs: inputData[], preProcess?: (s: dry_system, index: number, input: inputData) => undefined | inputData[]): this;
-    next(): T extends [] ? T_accumulate : validSetFormat<T[0]["type"]>;
-    isFinalized(): this is inputRequester_finalized<T_accumulate>;
-    extend<T2 extends inputData>(s: dry_system, f: (s: dry_system, prev: T_accumulate) => T2[] | validSetFormat<T2["type"]>): inputRequester<inputType, [...T, T2], [...T_accumulate, T2], T2>;
-    extendMultiple<T2 extends inputData, Len extends number, X extends inputData[] = Tuple_any<T2, Len>>(s: dry_system, len: Len, f: (s: dry_system, prev: T_accumulate) => T2[]): inputRequester<K, [...T, ...X], [...T_accumulate, ...X], T2>;
-    merge<T2 extends inputData[], T_accumulate2 extends Exclude<inputData[], []>, T_data_last_2 extends inputData>(requester: inputRequester<inputType, T2, T_accumulate2, T_data_last_2>): inputRequester<inputType, [...T, ...T2], [...T_accumulate, ...T_accumulate2], T_data_last_2>;
-    merge_with_signature(requester: inputRequester<any, inputData[], inputData[]>): this;
-    fill(s: dry_system, requester: inputRequester<any, inputData[], inputData[]>): this;
-    /**@deprecated */
-    extendOverride(s: dry_system, cond: (s: dry_system, prev: T_data_last) => boolean): this;
-}
-export declare class inputRequester_multiple<K extends inputType, Len extends number> extends inputRequester<K, Tuple_any<inputDataSpecific<K>, Len>> {
-    __multiple_len: Len;
-    constructor(len: Len, type: K, validSet: Exclude<inputDataSpecific<K>[], []>);
-    updateValidFlag(set: inputData[]): void;
-    apply(s: dry_system, input: Tuple_any<inputDataSpecific<K>, Len> extends [infer head, ...any[]] ? head : inputData_standard): any;
-    applyMultiple(s: dry_system, inputs: inputData[], preProcess?: (s: dry_system, index: number, input: inputData) => undefined | inputData[]): this;
-}
-declare class leaf<T extends inputData> {
-    path: inputData[];
-    cache: T[];
-    allIsValid: boolean;
-    constructor(data: T[] | undefined, path?: inputData[]);
-}
-declare class inputRequestCache<T extends Exclude<inputData[], []>> {
-    tree: leaf<inputData>[];
-    constructor(initial?: T | []);
-    private verify;
-    extend<T2 extends inputData>(s: dry_system, f: (s: dry_system, prev: inputData[]) => T2[] | validSetFormat, extraCond?: (s: dry_system, k: T2[]) => boolean): void;
-    merge(requester: inputRequestCache<any>): void;
-    get(depth: number): leaf<inputData_standard>[];
-}
-export declare class inputApplicator<ParamType extends any[], InputType extends Exclude<inputData[], []>> {
-    private __p;
-    private __f;
-    constructor(f: (...param: [...ParamType, inputRequester_finalized<InputType>]) => Action[], p: ParamType, thisParam?: any);
-    apply(input: inputRequester_finalized<InputType>): Action[];
-}
-export {};

package/lib/_queenSystem/handler/actionInputGenerator.js

@@ -1,373 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputApplicator = exports.inputRequester_multiple = exports.inputRequester = exports.inputFormRegistry = void 0;
-const systemRegistry_1 = require("../../data/systemRegistry");
-const actionGenrator_1 = require("./actionGenrator");
-/**
- * Merge with signature example:
- * A has input [X, Y, Z, K]
- * B has input [X, Y, K, L, Z]
- *
- * Merging these will yield C having input [...A, ...exclude B from A, stop at first not match in B]
- * the previous example will results to [X, Y, Z, K, L, Z]
- * [X, Y, Z, K] from A
- * and [L, Z] from B after filling A's input into B as best as we can
- * well..not rlly but I do not want to recur try to apply every input every time we apply new inputs
- *
- * oh also apply returns, please make sure to overwrite the val after apply
- */
-exports.inputFormRegistry = {
-    zone(s, z) {
-        const o = actionGenrator_1.actionFormRegistry.zone(s, z);
-        return {
-            type: systemRegistry_1.inputType.zone,
-            data: o,
-            is: o.is,
-            of: o.of,
-        };
-    },
-    card(s, c) {
-        const o = actionGenrator_1.actionFormRegistry.card(s, c);
-        return {
-            type: systemRegistry_1.inputType.card,
-            data: o,
-            is: o.is
-        };
-    },
-    effect(s, c, e) {
-        const o = actionGenrator_1.actionFormRegistry.effect(s, c, e);
-        return {
-            type: systemRegistry_1.inputType.effect,
-            data: o,
-            is: o.is
-        };
-    },
-    subtype(s, c, e, st) {
-        const o = actionGenrator_1.actionFormRegistry.subtype(s, c, e, st);
-        return {
-            type: systemRegistry_1.inputType.effectSubtype,
-            data: o,
-            is: o.is
-        };
-    },
-    player(s, pid) {
-        const o = actionGenrator_1.actionFormRegistry.player(s, pid);
-        return {
-            type: systemRegistry_1.inputType.player,
-            data: o,
-            is: o.is,
-        };
-    },
-    pos(s, pos) {
-        const o = actionGenrator_1.actionFormRegistry.position(s, pos);
-        return {
-            type: systemRegistry_1.inputType.position,
-            data: o,
-            is: o.is
-        };
-    },
-    num(num) { return { type: systemRegistry_1.inputType.number, data: num }; },
-    str(str) { return { type: systemRegistry_1.inputType.string, data: str }; },
-    bool(bool) { return { type: systemRegistry_1.inputType.boolean, data: bool }; },
-};
-class inputRequester {
-    emplaceReserve() {
-        this.__curr = undefined;
-        this.__inner_res = this.reserved_inner_res;
-    }
-    updateValidFlag(set) {
-        if (set === undefined)
-            this.__valid_flag = true;
-        else
-            this.__valid_flag = (set.length !== 0);
-    }
-    get len() {
-        return this.__len;
-    }
-    constructor(type, validSet) {
-        this.__inner_res = [];
-        this.__func_arr = [];
-        this.__queue = [];
-        this.__do_pre_fill_when_merge = false;
-        this.__len = 1;
-        this.__cursor_f_arr = 0;
-        this.reserved_inner_res = [];
-        this.__curr = [type, validSet];
-        if (validSet === undefined)
-            this.__valid_flag = true;
-        else
-            this.__valid_flag = (validSet.length !== 0);
-        this.cache = new inputRequestCache(validSet);
-    }
-    hasInput() {
-        return this.__valid_flag && (this.__curr === undefined || this.__curr[1] === undefined || this.__curr[1].length !== 0);
-    }
-    verify(a) {
-        return a.length === 2 && typeof a[0] === "number"; //rough check
-    }
-    isCurrentInputAllows(s, k) {
-        if (k === undefined)
-            return false;
-        const t = this.next();
-        const c1 = this.verify(t);
-        const c2 = t[0] === k.type;
-        const c3 = (t[1] === undefined ||
-            t[1].some(i => i !== undefined && s.generateSignature(i) === s.generateSignature(k)));
-        //console.log("Checking applicavbility of input : ", k, " -- ",  [c1, c2, c3, (t[1] as inputData[]).map(i => s.generateSignature(i))])
-        return c1 && c2 && c3;
-    }
-    copyToNext(next) {
-        next.__queue.unshift(...this.__queue);
-        next.__inner_res = this.__inner_res;
-    }
-    // protected apply_dry(s : dry_system){
-    //     let f = this.__func_arr[this.__cursor_f_arr]
-    //     this.__cursor_f_arr++
-    //     if(f !== undefined){
-    //         const t : inputData[] | validSetFormat = f(s, Array.from(this.__inner_res.values()))
-    //         if(this.verify(t)) this.__curr = t;
-    //         else this.__curr = [t[0].type, t]
-    //     } else if(this.__queue.length !== 0){
-    //         const next = this.__queue.shift()!
-    //         this.copyToNext(next)
-    //         return next as any
-    //     } else {
-    //         this.__curr = undefined
-    //     }
-    //     return this as any
-    // }
-    apply(s, input) {
-        let f = this.__func_arr[this.__cursor_f_arr];
-        this.__cursor_f_arr++;
-        const sig = s.generateSignature(input);
-        this.__inner_res.push(input);
-        this.reserved_inner_res.push(input);
-        if (f !== undefined) {
-            const t = f(s, Array.from(this.__inner_res.values()));
-            if (this.verify(t))
-                this.__curr = t;
-            else
-                this.__curr = [t[0].type, t];
-        }
-        else if (this.__queue.length !== 0) {
-            const next = this.__queue.shift();
-            this.copyToNext(next);
-            if (next.__do_pre_fill_when_merge)
-                next.applyMultiple(s, [...Array.from(next.__inner_res.values()), input]);
-            else
-                next.apply(s, input);
-            return next;
-        }
-        else {
-            this.__curr = undefined;
-        }
-        return this;
-    }
-    applyMultiple(s, inputs, preProcess) {
-        let mark = new Array(inputs.length).fill(false);
-        //console.log("logging from applyMultiple, trying to apply ", inputs, " to this Object")
-        let i = 0;
-        while (i < inputs.length && !this.isFinalized()) {
-            const x = preProcess ? preProcess(s, i, inputs[i]) : undefined;
-            if (x) {
-                x.forEach(k => {
-                    if (this.isCurrentInputAllows(s, k)) {
-                        this.apply(s, k);
-                    }
-                });
-            }
-            else if (this.isCurrentInputAllows(s, inputs[i])) {
-                mark[i] = true;
-                this.apply(s, inputs[i]);
-            }
-            i++;
-        }
-        console.log("Applied mask: ", mark);
-        return this;
-    }
-    next() {
-        return (this.__curr === undefined) ? this.__inner_res : this.__curr;
-    }
-    isFinalized() {
-        return this.__curr === undefined;
-    }
-    //extend DO check for chained validity
-    extend(s, f) {
-        this.__func_arr.push(f);
-        this.__len++;
-        this.cache.extend(s, f);
-        if (this.cache.tree.length === 0)
-            this.__valid_flag = false;
-        return this;
-    }
-    extendMultiple(s, len, f) {
-        if (len <= 0) {
-            this.__valid_flag = false;
-            return this;
-        }
-        this.__len += len;
-        this.cache.extend(s, f, (s, k) => k.length >= len);
-        this.__func_arr.push(f);
-        let k = len - 1;
-        while (k !== 0) {
-            this.__func_arr.push((s, prev) => {
-                return f(s, prev).filter(i => s.generateSignature(i) !== s.generateSignature(prev.at(-1)));
-            });
-            k--;
-        }
-        if (this.cache.tree.length === 0)
-            this.__valid_flag = false;
-        return this;
-    }
-    //merge DO NOT check for chained validity
-    merge(requester) {
-        this.__queue.push(requester);
-        if (requester.__valid_flag === false)
-            this.__valid_flag = false;
-        this.__len += requester.__len;
-        this.cache.merge(requester.cache);
-        return this;
-    }
-    merge_with_signature(requester) {
-        requester.__do_pre_fill_when_merge = true;
-        this.merge(requester);
-        return this;
-    }
-    fill(s, requester) {
-        this.applyMultiple(s, Array.from(requester.__inner_res.values()));
-        return this;
-    }
-    //adds a new condition on top of the old condition of the last input required
-    /**@deprecated */
-    extendOverride(s, cond) {
-        if (this.__func_arr.length === 0) {
-            if (this.__queue.length === 0) {
-                if (!this.__curr)
-                    return this;
-                if (!this.__curr[1])
-                    return this;
-                this.__curr[1] = this.__curr[1].filter(i => cond(s, i));
-                return this;
-            }
-            ;
-            return this.__queue.at(-1).extendOverride(s, cond);
-        }
-        ;
-        const oldCond = this.__func_arr.pop();
-        const newCond = function (f, f2, thisParam) {
-            return function (s, prev) {
-                const res = f(s, prev);
-                const res2 = thisParam.verify(res) ? res[1] : res;
-                if (!res2)
-                    return res;
-                return res2.filter(k => f2(s, k));
-            };
-        };
-        const k = newCond(oldCond, cond, this);
-        this.__func_arr.push(k);
-        this.cache.extend(s, k);
-        if (this.cache.tree.length === 0)
-            this.__valid_flag = false;
-        return this;
-    }
-}
-exports.inputRequester = inputRequester;
-class inputRequester_multiple extends inputRequester {
-    constructor(len, type, validSet) {
-        if (len < 0 || !Number.isFinite(len)) {
-            console.warn(`Something tried to create multiple inputs with len invalid (len = ${len})`);
-            len = 0;
-        }
-        super(type, validSet);
-        this.__valid_flag = validSet.length >= len;
-        this.__len = len;
-        this.__multiple_len = len;
-    }
-    updateValidFlag(set) {
-        this.__valid_flag = set.length >= this.__multiple_len;
-    }
-    apply(s, input) {
-        // console.log("From inside requester: ", this.__multiple_len, "Applying : ", input)
-        this.__multiple_len--;
-        if (this.__multiple_len === 0) {
-            // console.log("Len reaches 0, switching to super's apply")
-            return super.apply(s, input);
-        }
-        const i = input;
-        const sig = s.generateSignature(i);
-        this.__inner_res.push(i);
-        this.reserved_inner_res.push(i);
-        this.__curr[1] = this.__curr[1].filter(i => s.generateSignature(i) !== s.generateSignature(input));
-        // if(this.__multiple_len === 0) this.apply_dry(s)
-        return this;
-    }
-    applyMultiple(s, inputs, preProcess) {
-        super.applyMultiple(s, inputs, preProcess);
-        // console.log("From apply Multiple, afterwards: ", this.__multiple_len)
-        return this;
-    }
-}
-exports.inputRequester_multiple = inputRequester_multiple;
-class leaf {
-    constructor(data, path = []) {
-        this.path = [];
-        this.allIsValid = false;
-        if (data === undefined) {
-            this.allIsValid = true;
-            data = [];
-        }
-        this.cache = data;
-        this.path = path;
-    }
-}
-class inputRequestCache {
-    constructor(initial = []) {
-        this.tree = initial.map(i => new leaf([i]));
-    }
-    verify(a) {
-        return a.length === 2 && typeof a[0] === "number";
-    }
-    extend(s, f, extraCond = (s, k) => k.length !== 0) {
-        const limit = this.tree.length;
-        for (let i = 0; i < limit; i++) {
-            const curr_leaf = this.tree.shift();
-            if (curr_leaf instanceof leaf) {
-                const datum = curr_leaf.cache;
-                datum.forEach(k => {
-                    const newPath = [...curr_leaf.path, k];
-                    const res = f(s, newPath);
-                    if (this.verify(res)) {
-                        if (res[1] === undefined || res[1].length !== 0) {
-                            this.tree.push(new leaf(res[1], newPath));
-                        }
-                    }
-                    else {
-                        if (extraCond(s, res)) {
-                            this.tree.push(new leaf(res, newPath));
-                        }
-                    }
-                });
-            }
-            else {
-                this.tree.push(curr_leaf);
-            }
-        }
-    }
-    merge(requester) {
-        this.tree.push(...requester.tree);
-    }
-    get(depth) {
-        return this.tree.filter(i => i.path.length === depth);
-    }
-}
-class inputApplicator {
-    constructor(f, p, thisParam) {
-        this.__p = p;
-        this.__f = thisParam ? f.bind(thisParam) : f;
-    }
-    apply(input) {
-        let k = [...this.__p, input];
-        return this.__f(...k);
-    }
-}
-exports.inputApplicator = inputApplicator;

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

@@ -1,92 +0,0 @@
-import type { dry_card, dry_position, dry_system, dry_zone } from "../../data/systemRegistry";
-import type Effect from "../../types/abstract/gameComponents/effect";
-import { zoneRegistry } from "../../data/zoneRegistry";
-import type { Player_specific, Positionable } from "../../types/misc";
-import { inputRequester, inputRequester_multiple } from "./actionInputGenerator";
-import { inputType } from "../../data/systemRegistry";
-type Internal_regen_card = dry_card & {
-    ___zone: dry_zone;
-};
-type Internal_regen_pos = dry_position & {
-    ___zone: dry_zone;
-};
-declare class regen_cards {
-    s: dry_system;
-    cards: Internal_regen_card[];
-    constructor(s: dry_system, cards: Internal_regen_card[]);
-    ofArchtype(p: string): this;
-    ofSameArchtype(c1: dry_card): this;
-    ofSameField(c1: dry_card): this;
-    hasStatus(): this;
-    hasAutomate(): this;
-    isExposed(): this;
-    isCoverred(): this;
-    isBack(): this;
-    isFront(): this;
-    ofLevel(l: number): this;
-    ofAtLeastLevel(l: number): this;
-    ofDataID(s: string): this;
-    ofSameDataID(c_: dry_card): this;
-    pos(): regen_pos;
-    zones(): regen_zone;
-    filter(f?: (c: Internal_regen_card) => boolean): this;
-    once(e?: Effect<any>): inputRequester<inputType.card, [import("../../data/systemRegistry").inputData_card], [import("../../data/systemRegistry").inputData_card], import("../../data/systemRegistry").inputData_card, import("../../data/systemRegistry").inputData_card, []>;
-    many<L extends number>(l: L, e?: Effect<any>): inputRequester_multiple<inputType.card, L>;
-    clean(e?: Effect<any>): dry_card[];
-}
-declare class regen_pos {
-    s: dry_system;
-    pos: Internal_regen_pos[];
-    constructor(s: dry_system, pos: Internal_regen_pos[]);
-    isEmpty(): this;
-    isOccupied(): this;
-    isExposed(): this;
-    isCoverred(): this;
-    isBack(): this;
-    isFront(): this;
-    cards(): regen_cards;
-    zones(): regen_zone;
-    filter(f?: (p: Internal_regen_pos) => boolean): this;
-    once(e?: Effect<any>): inputRequester<inputType.position, [import("../../data/systemRegistry").inputData_pos], [import("../../data/systemRegistry").inputData_pos], import("../../data/systemRegistry").inputData_pos, import("../../data/systemRegistry").inputData_pos, []>;
-    many<L extends number>(l: L, e?: Effect<any>): inputRequester_multiple<inputType.position, L>;
-    clean(e?: Effect<any>): dry_position[];
-}
-declare class regen_zone {
-    s: dry_system;
-    zones: dry_zone[];
-    constructor(s: dry_system, zones: dry_zone[]);
-    cards(): regen_cards;
-    pos(): regen_pos;
-    ofSamePlayer(pstat?: Player_specific): this;
-    ofSamePlayerType(pstat?: Player_specific): this;
-    filter(f?: (z: dry_zone) => boolean): this;
-    once(e?: Effect<any>): inputRequester<inputType.zone, [import("../../data/systemRegistry").inputData_zone], [import("../../data/systemRegistry").inputData_zone], import("../../data/systemRegistry").inputData_zone, import("../../data/systemRegistry").inputData_zone, []>;
-    many<L extends number>(l: L, e?: Effect<any>): inputRequester_multiple<inputType.zone, L>;
-    clean(e?: Effect<any>): dry_zone[];
-}
-declare class regen_nums {
-    s: dry_system;
-    nums: number[];
-    constructor(s: dry_system, nums: number[]);
-    filter(f?: (n: number) => boolean): void;
-    once(e?: Effect<any>): inputRequester<inputType.number, [import("../../data/systemRegistry").inputData_num], [import("../../data/systemRegistry").inputData_num], import("../../data/systemRegistry").inputData_num, import("../../data/systemRegistry").inputData_num, []>;
-    many<L extends number>(l: L, e?: Effect<any>): inputRequester_multiple<inputType.number, L>;
-}
-declare class inputRequesterGenerator {
-    field(s: dry_system, c: Player_specific | Positionable): regen_zone;
-    grave(s: dry_system, c: Player_specific | Positionable): regen_zone;
-    deck(s: dry_system, c: Player_specific | Positionable): regen_zone;
-    hand(s: dry_system, c: Player_specific | Positionable): regen_zone;
-    specificType(s: dry_system, c: Player_specific | Positionable, zType: zoneRegistry): regen_zone;
-    oppositeZoneTo(s: dry_system, c: dry_card): regen_zone;
-    allZones(s: dry_system, c: Player_specific | Positionable): regen_zone;
-    nums(s: dry_system, ...nums: (number[] | number)[]): regen_nums;
-}
-export type T_regen<T extends "card" | "zone" | "pos" | "nums" = "card" | "zone" | "pos" | "nums"> = {
-    card: regen_cards;
-    zone: regen_zone;
-    pos: regen_pos;
-    nums: regen_nums;
-}[T];
-declare const Request: inputRequesterGenerator;
-export default Request;