@gamepark/zenith 0.0.1

package/dist/rules/effect/ConditionalRule.js

@@ -0,0 +1,197 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/effect/Effect");
+var EffectType_1 = require("../../material/effect/EffectType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var EffectHelper_1 = require("../helper/EffectHelper");
+var Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var ConditionalRule = (function (_super) {
+    __extends(ConditionalRule, _super);
+    function ConditionalRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ConditionalRule.prototype.onRuleStart = function () {
+        var condition = this.effect.condition;
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        if (this.isDoCondition(condition) && this.effect.mandatory) {
+            moves.push.apply(moves, __spreadArray([], __read((0, EffectHelper_1.getEffectRule)(this.game, condition.effect).getAutomaticEffectMoves()), false));
+            return moves;
+        }
+        if (this.isLeaderCondition(condition) || this.isHaveCreditCondition(condition)) {
+            this.removeCondition();
+            return this.afterEffectPlayed();
+        }
+        return [];
+    };
+    ConditionalRule.prototype.getPlayerMoves = function () {
+        var condition = this.effect.condition;
+        if (this.isDoCondition(condition)) {
+            if (!this.isAutomaticEffect) {
+                var moves = [];
+                if (!this.effect.mandatory && !this.remind(Memory_1.Memory.CantPass))
+                    moves.push(this.customMove(CustomMoveType_1.CustomMoveType.Pass));
+                moves.push.apply(moves, __spreadArray([], __read((0, EffectHelper_1.getEffectRule)(this.game, condition.effect).getPlayerMoves()), false));
+                return moves;
+            }
+            return [this.customMove(CustomMoveType_1.CustomMoveType.Pass), this.customMove(CustomMoveType_1.CustomMoveType.DoCondition)];
+        }
+        return [];
+    };
+    ConditionalRule.prototype.onCustomMove = function (move) {
+        if ((0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.Pass)(move)) {
+            this.removeFirstEffect();
+            return this.afterEffectPlayed();
+        }
+        if ((0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.DoCondition)(move)) {
+            var condition_1 = this.effect.condition;
+            if (!this.isDoCondition(condition_1))
+                return [];
+            var conditionEffect = (0, EffectHelper_1.getEffectRule)(this.game, condition_1.effect);
+            var extraData = conditionEffect.getExtraDataFromMove(move);
+            this.addEffectAndRemoveCondition(extraData);
+            return this.afterEffectPlayed();
+        }
+        this.onEffectPlayed(move);
+        var condition = this.effect.condition;
+        if (this.isDoCondition(condition)) {
+            var moves = (0, EffectHelper_1.getEffectRule)(this.game, condition.effect).onCustomMove(move);
+            moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+            return moves;
+        }
+        return [];
+    };
+    ConditionalRule.prototype.afterItemMove = function (move) {
+        var done = this.onEffectPlayed(move);
+        if (done) {
+            return this.afterEffectPlayed();
+        }
+        return [];
+    };
+    ConditionalRule.prototype.onEffectPlayed = function (move) {
+        var condition = this.effect.condition;
+        if (this.isDoCondition(condition)) {
+            if (this.isAutomaticEffect)
+                return;
+            var conditionEffect = (0, EffectHelper_1.getEffectRule)(this.game, condition.effect);
+            var done = conditionEffect.decrement(move);
+            if (done) {
+                var extraData = conditionEffect.getExtraDataFromMove(move);
+                this.removeCondition(extraData);
+            }
+            else {
+                this.memorize(Memory_1.Memory.CantPass, true);
+            }
+            return done;
+        }
+        return true;
+    };
+    Object.defineProperty(ConditionalRule.prototype, "isAutomaticEffect", {
+        get: function () {
+            var condition = this.effect.condition;
+            if (!this.isDoCondition(condition))
+                return false;
+            return condition.effect.type === EffectType_1.EffectType.GiveCredit || condition.effect.type === EffectType_1.EffectType.GiveZenithium;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConditionalRule.prototype.isDoCondition = function (condition) {
+        return condition.type === Effect_1.ConditionType.DoEffect;
+    };
+    ConditionalRule.prototype.isLeaderCondition = function (condition) {
+        return condition.type === Effect_1.ConditionType.Leader;
+    };
+    ConditionalRule.prototype.isHaveCreditCondition = function (condition) {
+        return condition.type === Effect_1.ConditionType.HaveCredits;
+    };
+    ConditionalRule.prototype.isPossible = function () {
+        var condition = this.effect.condition;
+        if (this.isDoCondition(condition)) {
+            var conditionEffect = (0, EffectHelper_1.getEffectRule)(this.game, condition.effect);
+            return conditionEffect.isPossible() && (0, EffectHelper_1.getEffectRule)(this.game, this.effect.effect).isPossible();
+        }
+        if (this.isLeaderCondition(condition)) {
+            return this.playerHelper.isLeader;
+        }
+        if (this.isHaveCreditCondition(condition)) {
+            return this.playerHelper.credits >= condition.min;
+        }
+        return false;
+    };
+    ConditionalRule.prototype.addEffectAndRemoveCondition = function (extraData) {
+        var _this = this;
+        this.memorize(Memory_1.Memory.Effects, function (effects) {
+            var firstEffect = effects[0];
+            var condition = firstEffect.condition, effect = firstEffect.effect;
+            if (extraData) {
+                (0, EffectHelper_1.getEffectRule)(_this.game, effect).setExtraData(extraData);
+            }
+            return __spreadArray([
+                __assign(__assign({}, condition.effect), { effectSource: firstEffect.effectSource }),
+                __assign(__assign({}, effect), { effectSource: firstEffect.effectSource })
+            ], __read(effects.slice(1)), false);
+        });
+    };
+    ConditionalRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.CantPass);
+        return [];
+    };
+    return ConditionalRule;
+}(index_1.EffectRule));
+exports.ConditionalRule = ConditionalRule;

package/dist/rules/effect/DevelopTechnologyRule.d.ts

@@ -0,0 +1,11 @@
+import { CustomMove, ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { DevelopTechnologyEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class DevelopTechnologyRule extends EffectRule<DevelopTechnologyEffect> {
+    getPlayerMoves(): (CustomMove | import("@gamepark/rules-api").MoveItem<number, number, number>)[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    get technologies(): import("@gamepark/rules-api").Material<number, number, number>;
+    isPossible(): boolean;
+    get technologyTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effect/DevelopTechnologyRule.js

@@ -0,0 +1,133 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevelopTechnologyRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var TechnologyHelper_1 = require("../helper/TechnologyHelper");
+var index_1 = require("./index");
+var DevelopTechnologyRule = (function (_super) {
+    __extends(DevelopTechnologyRule, _super);
+    function DevelopTechnologyRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DevelopTechnologyRule.prototype.getPlayerMoves = function () {
+        return __spreadArray(__spreadArray([], __read(this.technologies.moveItems(function (item) { return (__assign(__assign({}, item.location), { x: item.location.x + 1 })); })), false), [
+            this.customMove(CustomMoveType_1.CustomMoveType.Pass)
+        ], false);
+    };
+    DevelopTechnologyRule.prototype.afterItemMove = function (move) {
+        var _a;
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.TechMarker)(move))
+            return [];
+        var moves = [];
+        if (!this.effect.free) {
+            var cost = move.location.x - ((_a = this.effect.discount) !== null && _a !== void 0 ? _a : 0);
+            if (cost) {
+                moves.push(this.playerHelper.zenithiumMaterial.deleteItem(cost));
+            }
+        }
+        moves.push.apply(moves, __spreadArray([], __read(new TechnologyHelper_1.TechnologyHelper(this.game).applyTechnology(move)), false));
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    DevelopTechnologyRule.prototype.onCustomMove = function (move) {
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.Pass)(move))
+            return [];
+        this.removeFirstEffect();
+        return this.afterEffectPlayed();
+    };
+    Object.defineProperty(DevelopTechnologyRule.prototype, "technologies", {
+        get: function () {
+            var _this = this;
+            var zenithium = this.playerHelper.zenithium;
+            var techBoard = this.material(MaterialType_1.MaterialType.TechnologyBoard)
+                .locationId(function (id) { var _a; return id === ((_a = _this.effect.faction) !== null && _a !== void 0 ? _a : id); })
+                .getIndexes();
+            var tokens = this.technologyTokens.parent(function (p) { return techBoard.includes(p); });
+            if (!tokens.length)
+                return tokens;
+            if (this.effect.free && this.effect.lowest) {
+                var lowestX_1 = tokens.minBy(function (item) { return item.location.x; }).getItem().location.x;
+                return tokens.filter(function (item) { return item.location.x === lowestX_1; });
+            }
+            var discount = this.effect.discount;
+            if (discount !== undefined) {
+                return tokens.filter(function (item) {
+                    return item.location.x + 1 - discount <= zenithium;
+                });
+            }
+            return tokens;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DevelopTechnologyRule.prototype.isPossible = function () {
+        return this.technologies.length > 0;
+    };
+    Object.defineProperty(DevelopTechnologyRule.prototype, "technologyTokens", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.TechMarker)
+                .location(LocationType_1.LocationType.TechnologyBoardTokenSpace)
+                .player(this.playerHelper.team)
+                .location(function (l) { return l.x < 5; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DevelopTechnologyRule;
+}(index_1.EffectRule));
+exports.DevelopTechnologyRule = DevelopTechnologyRule;

package/dist/rules/effect/DiscardRule.d.ts

@@ -0,0 +1,18 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { DiscardEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class DiscardRule extends EffectRule<DiscardEffect> {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    getExtraDataFromMove(move: ItemMove): {
+        quantity: number;
+        influence: import("../../material/Influence").Influence;
+    } | {
+        quantity?: undefined;
+        influence?: undefined;
+    };
+    afterItemMove(move: ItemMove): MaterialMove[];
+    isPossible(): boolean;
+    get hand(): import("@gamepark/rules-api").Material<number, number, number>;
+    onRuleEnd(): never[];
+}

package/dist/rules/effect/DiscardRule.js

@@ -0,0 +1,107 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscardRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Agents_1 = require("../../material/Agents");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var DiscardRule = (function (_super) {
+    __extends(DiscardRule, _super);
+    function DiscardRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DiscardRule.prototype.onRuleStart = function () {
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        this.memorize(Memory_1.Memory.CurrentEffect, JSON.parse(JSON.stringify(this.effect)));
+        var effect = this.effect;
+        if (effect.full) {
+            moves.push(this.hand.moveItemsAtOnce({
+                type: LocationType_1.LocationType.AgentDiscard
+            }));
+            this.removeFirstEffect();
+            moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        }
+        return moves;
+    };
+    DiscardRule.prototype.getPlayerMoves = function () {
+        var moves = [];
+        moves.push.apply(moves, __spreadArray([], __read(this.hand.moveItems({
+            type: LocationType_1.LocationType.AgentDiscard
+        })), false));
+        return moves;
+    };
+    DiscardRule.prototype.getExtraDataFromMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDiscard) {
+            var card = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
+            var agent = Agents_1.Agents[card.id];
+            return { quantity: agent.cost, influence: agent.influence };
+        }
+        return {};
+    };
+    DiscardRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) || move.location.type !== LocationType_1.LocationType.AgentDiscard)
+            return [];
+        this.removeFirstEffect();
+        return this.afterEffectPlayed();
+    };
+    DiscardRule.prototype.isPossible = function () {
+        return this.hand.length > 0;
+    };
+    Object.defineProperty(DiscardRule.prototype, "hand", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.PlayerHand).player(this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DiscardRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.CurrentEffect);
+        return [];
+    };
+    return DiscardRule;
+}(index_1.EffectRule));
+exports.DiscardRule = DiscardRule;

package/dist/rules/effect/EffectRule.d.ts

@@ -0,0 +1,27 @@
+import { CustomMove, ItemMove, MaterialGame, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleMove } from '@gamepark/rules-api/dist/material/moves';
+import { RuleStep } from '@gamepark/rules-api/dist/material/rules/RuleStep';
+import { PlayMoveContext } from '@gamepark/rules-api/dist/Rules';
+import { Effect, ExpandedEffect } from '../../material/effect/Effect';
+import { TeamColor } from '../../TeamColor';
+import { PlayerHelper } from '../helper/PlayerHelper';
+import { RuleId } from '../RuleId';
+export declare abstract class EffectRule<E extends Effect = Effect> extends PlayerTurnRule {
+    effect: ExpandedEffect<E>;
+    constructor(game: MaterialGame, effect?: E);
+    onRuleStart(_move?: RuleMove, _previousRule?: RuleStep, _context?: PlayMoveContext): MaterialMove[];
+    getAutomaticEffectMoves(): MaterialMove[];
+    isPossible(): boolean;
+    get creditMoney(): import("@gamepark/rules-api").MaterialMoney<number, number, number, import("../../material/Credit").Credit>;
+    setExtraData(_extraData: Record<string, unknown>): void;
+    decrement(_move: ItemMove | CustomMove): boolean;
+    getExtraDataFromMove(_move: ItemMove | CustomMove): Record<string, unknown>;
+    get effects(): ExpandedEffect[];
+    get firstEffect(): ExpandedEffect | undefined;
+    get playerHelper(): PlayerHelper;
+    removeFirstEffect(): void;
+    applyFirstEffect(): import("@gamepark/rules-api").StartRule<RuleId>[];
+    afterEffectPlayed(): MaterialMove[];
+    get opponentTeam(): TeamColor;
+    removeCondition(extraData?: Record<string, unknown>): void;
+}

package/dist/rules/effect/EffectRule.js

@@ -0,0 +1,161 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Credit_1 = require("../../material/Credit");
+var MaterialType_1 = require("../../material/MaterialType");
+var TeamColor_1 = require("../../TeamColor");
+var EffectHelper_1 = require("../helper/EffectHelper");
+var EffectRuleIds_1 = require("../helper/EffectRuleIds");
+var PlayerHelper_1 = require("../helper/PlayerHelper");
+var Memory_1 = require("../Memory");
+var RuleId_1 = require("../RuleId");
+var EffectRule = (function (_super) {
+    __extends(EffectRule, _super);
+    function EffectRule(game, effect) {
+        var _this = _super.call(this, game) || this;
+        _this.effect = (effect !== null && effect !== void 0 ? effect : _this.firstEffect);
+        return _this;
+    }
+    EffectRule.prototype.onRuleStart = function (_move, _previousRule, _context) {
+        if (!this.isPossible()) {
+            this.removeFirstEffect();
+            return this.afterEffectPlayed();
+        }
+        return [];
+    };
+    EffectRule.prototype.getAutomaticEffectMoves = function () {
+        return [];
+    };
+    EffectRule.prototype.isPossible = function () {
+        return true;
+    };
+    Object.defineProperty(EffectRule.prototype, "creditMoney", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.CreditToken).money(Credit_1.credits);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EffectRule.prototype.setExtraData = function (_extraData) { };
+    EffectRule.prototype.decrement = function (_move) {
+        return true;
+    };
+    EffectRule.prototype.getExtraDataFromMove = function (_move) {
+        return {
+            quantity: 1
+        };
+    };
+    Object.defineProperty(EffectRule.prototype, "effects", {
+        get: function () {
+            return this.remind(Memory_1.Memory.Effects);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EffectRule.prototype, "firstEffect", {
+        get: function () {
+            return this.effects[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EffectRule.prototype, "playerHelper", {
+        get: function () {
+            return new PlayerHelper_1.PlayerHelper(this.game, this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EffectRule.prototype.removeFirstEffect = function () {
+        this.memorize(Memory_1.Memory.Effects, function (effects) {
+            effects.shift();
+            return effects;
+        });
+    };
+    EffectRule.prototype.applyFirstEffect = function () {
+        var effect = this.firstEffect;
+        if (!effect) {
+            return [];
+        }
+        return [this.startRule(EffectRuleIds_1.EffectRuleIds[effect.type])];
+    };
+    EffectRule.prototype.afterEffectPlayed = function () {
+        var moves = this.applyFirstEffect();
+        if (!moves.some(function (move) { return (0, rules_api_1.isStartRule)(move) || (0, rules_api_1.isStartPlayerTurn)(move); }) && !this.effects.length) {
+            moves.push(this.startRule(RuleId_1.RuleId.Refill));
+        }
+        return moves;
+    };
+    Object.defineProperty(EffectRule.prototype, "opponentTeam", {
+        get: function () {
+            return this.playerHelper.team === TeamColor_1.TeamColor.White ? TeamColor_1.TeamColor.Black : TeamColor_1.TeamColor.White;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EffectRule.prototype.removeCondition = function (extraData) {
+        var _this = this;
+        this.memorize(Memory_1.Memory.Effects, function (effects) {
+            var firstEffect = effects[0];
+            var effect = firstEffect.effect;
+            if (extraData) {
+                (0, EffectHelper_1.getEffectRule)(_this.game, effect).setExtraData(extraData);
+            }
+            return __spreadArray([__assign(__assign({}, effect), { effectSource: firstEffect.effectSource })], __read(effects.slice(1)), false);
+        });
+    };
+    return EffectRule;
+}(rules_api_1.PlayerTurnRule));
+exports.EffectRule = EffectRule;

package/dist/rules/effect/ExileRule.d.ts

@@ -0,0 +1,22 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { ExileEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class ExileRule extends EffectRule<ExileEffect> {
+    isPossible(): boolean;
+    getPlayerMoves(): MaterialMove[];
+    decrement(move: ItemMove): boolean;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    getExtraDataFromMove(move: ItemMove): {
+        quantity: number;
+        influence: import("../../material/Influence").Influence;
+    } | {
+        quantity: number;
+        influence?: undefined;
+    } | {
+        quantity?: undefined;
+        influence?: undefined;
+    };
+    exileOneCard(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    exileMultipleCards(): MaterialMove[];
+    get cards(): import("@gamepark/rules-api").Material<number, number, number>;
+}