qpremake 1.5.1

package/lib/types/effects/effectTypes/initEffect.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const triggerEffect_1 = __importDefault(require("./triggerEffect"));
+const actionRegistry_1 = __importDefault(require("../../../data/actionRegistry"));
+const zoneRegistry_1 = require("../../../data/zoneRegistry");
+class InitEffect extends triggerEffect_1.default {
+    canRespondAndActivate(e, c, system, a) {
+        if (a.typeID !== actionRegistry_1.default.a_pos_change && a.typeID !== actionRegistry_1.default.a_pos_change_force)
+            return false;
+        let targets = a.targets;
+        let zone = system.getZoneWithID(targets[1].pos.zoneID);
+        if (!zone)
+            return false;
+        if (targets[0].is(c) &&
+            zone.types.includes(zoneRegistry_1.zoneRegistry.z_field))
+            return super.canRespondAndActivate(e, c, system, a);
+        return false;
+    }
+}
+exports.default = InitEffect;

package/lib/types/effects/effectTypes/lockEffect.d.ts

@@ -0,0 +1,9 @@
+import { type Action } from "../../../_queenSystem/handler/actionGenrator";
+import type Card from "../../abstract/gameComponents/card";
+import type { dry_effect, dry_system } from "../../../data/systemRegistry";
+import PassiveEffect from "./passiveEffect";
+declare class LockEffect extends PassiveEffect {
+    canRespondAndActivate(e: dry_effect, c: Card, s: dry_system, a: Action): false | -1;
+    parseAfterActivate(e: dry_effect, c: Card, system: dry_system, res: Action[]): void;
+}
+export default LockEffect;

package/lib/types/effects/effectTypes/lockEffect.js

@@ -0,0 +1,25 @@
+"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");
+// import type { subTypeOverrideConflict } from "../../errors"
+const passiveEffect_1 = __importDefault(require("./passiveEffect"));
+class LockEffect extends passiveEffect_1.default {
+    canRespondAndActivate(e, c, s, a) {
+        //enforces only respond in the chain phase
+        if (!a.is("a_pos_change") && !a.is("a_pos_change_force"))
+            return false;
+        if (!a.targets[0].is(c))
+            return false;
+        if (s.turnAction && s.turnAction.id !== a.id)
+            return false;
+        return super.canRespondAndActivate(e, c, s, a);
+    }
+    parseAfterActivate(e, c, system, res) {
+        const cause = actionGenrator_1.actionFormRegistry.effect(system, c, e);
+        res.unshift(actionGenrator_1.actionConstructorRegistry.a_negate_action(cause));
+    }
+}
+exports.default = LockEffect;

package/lib/types/effects/effectTypes/manualEffect.d.ts

@@ -0,0 +1,9 @@
+import { type Action } from "../../../_queenSystem/handler/actionGenrator";
+import type Card from "../../abstract/gameComponents/card";
+import type { dry_effect, dry_system } from "../../../data/systemRegistry";
+import EffectType from "../../abstract/gameComponents/effectType";
+declare class ManualEffect extends EffectType {
+    canRespondAndActivate(e: dry_effect, c: Card, system: dry_system, a: Action): boolean;
+    parseAfterActivate(e: dry_effect, c: Card, system: dry_system, res: Action[]): void;
+}
+export default ManualEffect;

package/lib/types/effects/effectTypes/manualEffect.js

@@ -0,0 +1,18 @@
+"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");
+const effectType_1 = __importDefault(require("../../abstract/gameComponents/effectType"));
+class ManualEffect extends effectType_1.default {
+    //behaviors:
+    //manual effect uhh just sits there, until the action "activate effect" forcefull activate it
+    canRespondAndActivate(e, c, system, a) {
+        return false;
+    }
+    parseAfterActivate(e, c, system, res) {
+        res.push(actionGenrator_1.actionConstructorRegistry.a_disable_card(system, c)(actionGenrator_1.actionFormRegistry.card(system, c)));
+    }
+}
+exports.default = ManualEffect;

package/lib/types/effects/effectTypes/passiveEffect.d.ts

@@ -0,0 +1,9 @@
+import type { Action } from "../../../_queenSystem/handler/actionGenrator";
+import type Card from "../../abstract/gameComponents/card";
+import type { dry_system } from "../../../data/systemRegistry";
+import EffectType from "../../abstract/gameComponents/effectType";
+declare class PassiveEffect extends EffectType {
+    canRespondAndActivate(e: any, c: Card, system: dry_system, a: Action): false | -1;
+    parseAfterActivate(e: any, c: Card, system: dry_system, res: Action[]): void;
+}
+export default PassiveEffect;

package/lib/types/effects/effectTypes/passiveEffect.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// import type { subTypeOverrideConflict } from "../../errors"
+const effectType_1 = __importDefault(require("../../abstract/gameComponents/effectType"));
+class PassiveEffect extends effectType_1.default {
+    //behaviors:
+    //1. every action returns have isChain = true
+    //2. activates only in the chain phase
+    //3. when condition met -> returns the Action[] itself
+    canRespondAndActivate(e, c, system, a) {
+        //enforces only respond in the chain phase
+        if (!system.isInChainPhase)
+            return false;
+        return -1;
+    }
+    parseAfterActivate(e, c, system, res) {
+        res.forEach(i => i.isChain = true);
+    }
+}
+exports.default = PassiveEffect;

package/lib/types/effects/effectTypes/triggerEffect.d.ts

@@ -0,0 +1,9 @@
+import { type Action } from "../../../_queenSystem/handler/actionGenrator";
+import type Card from "../../abstract/gameComponents/card";
+import type { dry_effect, dry_system } from "../../../data/systemRegistry";
+import EffectType from "../../abstract/gameComponents/effectType";
+declare class TriggerEffect extends EffectType {
+    canRespondAndActivate(e: any, c: Card, system: dry_system, a: Action): -1 | boolean;
+    parseAfterActivate(e: dry_effect, c: Card, system: dry_system, res: Action[]): void;
+}
+export default TriggerEffect;

package/lib/types/effects/effectTypes/triggerEffect.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 });
+const actionGenrator_1 = require("../../../_queenSystem/handler/actionGenrator");
+const effectType_1 = __importDefault(require("../../abstract/gameComponents/effectType"));
+class TriggerEffect extends effectType_1.default {
+    //behaviors:
+    //1. activates only in the trigger phase if and only if no subtype overrides the result 
+    //2. activate has 2 behaviors: 
+    //      action != "activate self" -> returns an "activate self" action, isChain = false
+    //      action == "activate self" -> returns whatever super.activate returns, isChain = true
+    canRespondAndActivate(e, c, system, a) {
+        //enforces only respond in the trigger phase
+        //if and only if no subtype overrides the result
+        //this function only runs if no override happens 
+        if (!system.isInTriggerPhase)
+            return false;
+        return -1;
+    }
+    parseAfterActivate(e, c, system, res) {
+        const cause = actionGenrator_1.actionFormRegistry.effect(system, c, e);
+        res.unshift(actionGenrator_1.actionConstructorRegistry.a_declare_activation(system, c, e)(cause));
+        res.forEach(i => i.isChain = false);
+    }
+}
+exports.default = TriggerEffect;

package/lib/types/errors/cannotLoad.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class cannotLoad extends error {
+    constructor(itemID: string, type?: string);
+}
+export default cannotLoad;

package/lib/types/errors/cannotLoad.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class cannotLoad extends error_1.default {
+    constructor(itemID, type) {
+        super();
+        this.messege = `Cannot load item ${itemID} ${type ? `type = ${type}` : ""}`;
+    }
+}
+exports.default = cannotLoad;

package/lib/types/errors/cardNotExist.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class cardNotExist extends error {
+    constructor();
+}
+export default cardNotExist;

package/lib/types/errors/cardNotExist.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class cardNotExist extends error_1.default {
+    constructor() {
+        super();
+        this.messege = `Try to access something thats not a card pretending to be a card`;
+    }
+}
+exports.default = cardNotExist;

package/lib/types/errors/cardNotInApplicableZone.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class cardNotInApplicableZone extends error {
+    constructor(zoneID: number, cardID: string);
+}
+export default cardNotInApplicableZone;

package/lib/types/errors/cardNotInApplicableZone.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class cardNotInApplicableZone extends error_1.default {
+    constructor(zoneID, cardID) {
+        super(cardID);
+        this.messege = `Action done when card is not in zone with id ${zoneID} is invalid, cardID = ${cardID}`;
+    }
+}
+exports.default = cardNotInApplicableZone;

package/lib/types/errors/effectCondNotMet.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class effectCondNotMet extends error {
+    constructor(eid: number, cid: string);
+}
+export default effectCondNotMet;

package/lib/types/errors/effectCondNotMet.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class effectCondNotMet extends error_1.default {
+    constructor(eid, cid) {
+        super(cid);
+        this.messege = `The card with id ${cid} cannot activate the effect with id ${eid}`;
+    }
+}
+exports.default = effectCondNotMet;

package/lib/types/errors/effectNotExist.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class effectNotExist extends error {
+    constructor(eid_or_index: string | number, cid: string);
+}
+export default effectNotExist;

package/lib/types/errors/effectNotExist.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class effectNotExist extends error_1.default {
+    constructor(eid_or_index, cid) {
+        super();
+        this.messege = `The effect with id / index ${eid_or_index} doesnt exist on the card reference with id ${cid}, wrong activation time perhaps?`;
+    }
+}
+exports.default = effectNotExist;

package/lib/types/errors/error.d.ts

@@ -0,0 +1,17 @@
+import { Action_class } from "../../_queenSystem/handler/actionGenrator";
+declare class debugInfo {
+    file: string;
+    func: string;
+    line: number;
+    constructor(file: string, func?: string, line?: number);
+    toString(): string;
+}
+declare class error extends Action_class<[], never, {}> {
+    messege: string;
+    callStack: debugInfo[];
+    cardID: string | undefined;
+    constructor(cardID?: string);
+    add(file: string, func?: string, line?: number): this;
+    toString(): string;
+}
+export default error;

package/lib/types/errors/error.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const actionRegistry_1 = __importDefault(require("../../data/actionRegistry"));
+const actionGenrator_1 = require("../../_queenSystem/handler/actionGenrator");
+//actions by default are NOT valid to listen to, they r just there
+class debugInfo {
+    constructor(file, func = "", line = -1) {
+        this.file = file;
+        this.line = line;
+        this.func = func;
+    }
+    toString() {
+        let str = 'file: ' + this.file;
+        if (this.func.length)
+            str += ", function: " + this.func;
+        if (this.line >= 0)
+            str += ", line: " + this.line;
+        return str;
+    }
+}
+class error extends actionGenrator_1.Action_class {
+    constructor(cardID) {
+        let o = (0, actionGenrator_1.getDefaultObjContructionObj)(actionRegistry_1.default.error);
+        let o2 = Object.assign(Object.assign({}, o), { cause: actionGenrator_1.actionFormRegistry.system(), targets: [] });
+        super(o2);
+        this.messege = "";
+        this.callStack = []; //larger index = higher hierachy
+        this.cardID = cardID;
+    }
+    add(file, func, line) {
+        this.callStack.push(new debugInfo(file, func, line));
+        return this;
+    }
+    toString() {
+        return 'Error: ' + this.messege + '\nAt\n' + this.callStack.map(i => i.toString()).join("\n");
+    }
+    ;
+}
+exports.default = error;

package/lib/types/errors/incorrectActionType.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class incorrectActiontype extends error {
+    constructor(got: string, expected: string);
+}
+export default incorrectActiontype;

package/lib/types/errors/incorrectActionType.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class incorrectActiontype extends error_1.default {
+    constructor(got, expected) {
+        super();
+        this.messege = `wrong action type received : got : ${got}, expected : ${expected}`;
+    }
+}
+exports.default = incorrectActiontype;

package/lib/types/errors/index.d.ts

@@ -0,0 +1,16 @@
+import cardNotExist from "./cardNotExist";
+import effectNotExist from "./effectNotExist";
+import cardNotInApplicableZone from "./cardNotInApplicableZone";
+import effectCondNotMet from "./effectCondNotMet";
+import invalidOrderMap from "./invalidOrderMap";
+import invalidPosition from "./invalidPosition";
+import unknownError from "./unknownError";
+import zoneAttrConflict from "./zoneAttrConflict";
+import zoneFull from "./zoneFull";
+import subTypeOverrideConflict from "./subTypeOverrideConflict";
+import unregisteredAction from "./unregisteredAction";
+import wrongEffectIdx from "./wrongEffectIdx";
+import cannotLoad from "./cannotLoad";
+import incorrectActiontype from "./incorrectActionType";
+import zoneNotExist from "./zoneNotExist";
+export { cardNotExist, cardNotInApplicableZone, effectCondNotMet, invalidOrderMap, invalidPosition, unknownError, zoneAttrConflict, zoneFull, effectNotExist, wrongEffectIdx, subTypeOverrideConflict, unregisteredAction, cannotLoad, incorrectActiontype, zoneNotExist };

package/lib/types/errors/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoneNotExist = exports.incorrectActiontype = exports.cannotLoad = exports.unregisteredAction = exports.subTypeOverrideConflict = exports.wrongEffectIdx = exports.effectNotExist = exports.zoneFull = exports.zoneAttrConflict = exports.unknownError = exports.invalidPosition = exports.invalidOrderMap = exports.effectCondNotMet = exports.cardNotInApplicableZone = exports.cardNotExist = void 0;
+const cardNotExist_1 = __importDefault(require("./cardNotExist"));
+exports.cardNotExist = cardNotExist_1.default;
+const effectNotExist_1 = __importDefault(require("./effectNotExist"));
+exports.effectNotExist = effectNotExist_1.default;
+const cardNotInApplicableZone_1 = __importDefault(require("./cardNotInApplicableZone"));
+exports.cardNotInApplicableZone = cardNotInApplicableZone_1.default;
+const effectCondNotMet_1 = __importDefault(require("./effectCondNotMet"));
+exports.effectCondNotMet = effectCondNotMet_1.default;
+const invalidOrderMap_1 = __importDefault(require("./invalidOrderMap"));
+exports.invalidOrderMap = invalidOrderMap_1.default;
+const invalidPosition_1 = __importDefault(require("./invalidPosition"));
+exports.invalidPosition = invalidPosition_1.default;
+const unknownError_1 = __importDefault(require("./unknownError"));
+exports.unknownError = unknownError_1.default;
+const zoneAttrConflict_1 = __importDefault(require("./zoneAttrConflict"));
+exports.zoneAttrConflict = zoneAttrConflict_1.default;
+const zoneFull_1 = __importDefault(require("./zoneFull"));
+exports.zoneFull = zoneFull_1.default;
+const subTypeOverrideConflict_1 = __importDefault(require("./subTypeOverrideConflict"));
+exports.subTypeOverrideConflict = subTypeOverrideConflict_1.default;
+const unregisteredAction_1 = __importDefault(require("./unregisteredAction"));
+exports.unregisteredAction = unregisteredAction_1.default;
+const wrongEffectIdx_1 = __importDefault(require("./wrongEffectIdx"));
+exports.wrongEffectIdx = wrongEffectIdx_1.default;
+const cannotLoad_1 = __importDefault(require("./cannotLoad"));
+exports.cannotLoad = cannotLoad_1.default;
+const incorrectActionType_1 = __importDefault(require("./incorrectActionType"));
+exports.incorrectActiontype = incorrectActionType_1.default;
+const zoneNotExist_1 = __importDefault(require("./zoneNotExist"));
+exports.zoneNotExist = zoneNotExist_1.default;

package/lib/types/errors/invalidOrderMap.d.ts

@@ -0,0 +1,6 @@
+import error from "./error";
+declare class invalidOrderMap extends error {
+    orderMap: Map<number, number>;
+    constructor(orderMap: Map<number, number>);
+}
+export default invalidOrderMap;

package/lib/types/errors/invalidOrderMap.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class invalidOrderMap extends error_1.default {
+    constructor(orderMap) {
+        super();
+        this.orderMap = orderMap;
+        this.messege = `Invalid order map`;
+    }
+}
+exports.default = invalidOrderMap;

package/lib/types/errors/invalidPosition.d.ts

@@ -0,0 +1,6 @@
+import error from "./error";
+import type Position from "../abstract/generics/position";
+declare class invalidPosition extends error {
+    constructor(cid: string, p: Position);
+}
+export default invalidPosition;

package/lib/types/errors/invalidPosition.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class invalidPosition extends error_1.default {
+    constructor(cid, p) {
+        super(cid);
+        this.messege = `Cannot place card with id ${cid} on position ${p.toString()}`;
+    }
+}
+exports.default = invalidPosition;

package/lib/types/errors/subTypeOverrideConflict.d.ts

@@ -0,0 +1,7 @@
+import error from "./error";
+declare class subTypeOverrideConflict extends error {
+    effectID: string;
+    conflictIndexes: number[];
+    constructor(cid: string, eid: string, conflictIndexes: number[]);
+}
+export default subTypeOverrideConflict;

package/lib/types/errors/subTypeOverrideConflict.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class subTypeOverrideConflict extends error_1.default {
+    constructor(cid, eid, conflictIndexes) {
+        super(cid);
+        this.effectID = eid;
+        this.conflictIndexes = conflictIndexes;
+        this.messege = conflictIndexes.length + " subtypes attempted to override the result differently in card with id " + cid + " on effect " + eid;
+    }
+}
+exports.default = subTypeOverrideConflict;

package/lib/types/errors/unknownError.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class unknownError extends error {
+    constructor();
+}
+export default unknownError;

package/lib/types/errors/unknownError.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class unknownError extends error_1.default {
+    constructor() {
+        super();
+        this.messege = `Some error happened, I dunno what tho`;
+    }
+}
+exports.default = unknownError;

package/lib/types/errors/unregisteredAction.d.ts

@@ -0,0 +1,6 @@
+import error from "./error";
+import type { Action } from "../../_queenSystem/handler/actionGenrator";
+declare class unregisteredAction extends error {
+    constructor(a: Action);
+}
+export default unregisteredAction;

package/lib/types/errors/unregisteredAction.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class unregisteredAction extends error_1.default {
+    constructor(a) {
+        super();
+        this.messege = `an unregistered action is being resolved with type = ${a.type}`;
+    }
+}
+exports.default = unregisteredAction;

package/lib/types/errors/wrongEffectIdx.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class wrongEffectIdx extends error {
+    constructor(eidx: number, cid: string);
+}
+export default wrongEffectIdx;

package/lib/types/errors/wrongEffectIdx.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+//For accessing effect using idx instead of eid
+class wrongEffectIdx extends error_1.default {
+    constructor(eidx, cid) {
+        super(cid);
+        this.messege = `The card with id ${cid} do not have the effect at index ${eidx}`;
+    }
+}
+exports.default = wrongEffectIdx;

package/lib/types/errors/zoneAttrConflict.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class zoneAttrConflict extends error {
+    constructor(zoneID: number, actionName?: string, cardID?: string);
+}
+export default zoneAttrConflict;

package/lib/types/errors/zoneAttrConflict.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class zoneAttrConflict extends error_1.default {
+    constructor(zoneID, actionName, cardID) {
+        super(cardID);
+        this.messege = `Attempts to interact with zone with id ${zoneID} is not allowed by zone attribute`;
+        if (actionName)
+            this.messege += ", forbidden action: " + actionName;
+    }
+}
+exports.default = zoneAttrConflict;

package/lib/types/errors/zoneFull.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class zoneFull extends error {
+    constructor(zoneID: number, cardID: string);
+}
+export default zoneFull;

package/lib/types/errors/zoneFull.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class zoneFull extends error_1.default {
+    constructor(zoneID, cardID) {
+        super(cardID);
+        this.messege = `Cannot add card with id ${cardID} to zone with id ${zoneID} full, extra card discarded`;
+    }
+}
+exports.default = zoneFull;

package/lib/types/errors/zoneNotExist.d.ts

@@ -0,0 +1,5 @@
+import error from "./error";
+declare class zoneNotExist extends error {
+    constructor(zid: number);
+}
+export default zoneNotExist;

package/lib/types/errors/zoneNotExist.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("./error"));
+class zoneNotExist extends error_1.default {
+    constructor(zid) {
+        super();
+        this.messege = `Try to access something thats not a zone pretending to be a zone, accessing index : ${zid}`;
+    }
+}
+exports.default = zoneNotExist;