@gamepark/zenith 0.0.1

package/dist/rules/effect/ExileRule.js

@@ -0,0 +1,182 @@
+"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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+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.ExileRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Agents_1 = require("../../material/Agents");
+var EffectType_1 = require("../../material/effect/EffectType");
+var Influence_1 = require("../../material/Influence");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var index_1 = require("./index");
+var ExileRule = (function (_super) {
+    __extends(ExileRule, _super);
+    function ExileRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ExileRule.prototype.isPossible = function () {
+        var _a, _b;
+        if (((_a = this.firstEffect) === null || _a === void 0 ? void 0 : _a.type) === EffectType_1.EffectType.Conditional && !this.effect.quantities) {
+            return this.getPlayerMoves().length >= ((_b = this.effect.quantity) !== null && _b !== void 0 ? _b : 1);
+        }
+        return this.getPlayerMoves().length > 0;
+    };
+    ExileRule.prototype.getPlayerMoves = function () {
+        if (this.effect.quantities) {
+            return this.exileMultipleCards();
+        }
+        return this.exileOneCard();
+    };
+    ExileRule.prototype.decrement = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDiscard) {
+            if (this.effect.quantity) {
+                this.effect.quantity--;
+                return this.effect.quantity === 0 || !this.isPossible();
+            }
+        }
+        return true;
+    };
+    ExileRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDiscard) {
+            if (this.effect.quantity) {
+                this.effect.quantity--;
+            }
+            if (!this.effect.quantity || !this.isPossible()) {
+                this.removeFirstEffect();
+                return this.afterEffectPlayed();
+            }
+        }
+        return [];
+    };
+    ExileRule.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 };
+        }
+        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDiscard) {
+            if (this.effect.quantities && this.effect.factors) {
+                var index = this.effect.quantities.indexOf(move.indexes.length);
+                return { quantity: this.effect.factors[index] };
+            }
+        }
+        return {};
+    };
+    ExileRule.prototype.exileOneCard = function () {
+        var e_1, _a;
+        var allInfluences = Influence_1.influences;
+        var allCards = this.cards;
+        var indexes = [];
+        try {
+            for (var allInfluences_1 = __values(allInfluences), allInfluences_1_1 = allInfluences_1.next(); !allInfluences_1_1.done; allInfluences_1_1 = allInfluences_1.next()) {
+                var influence = allInfluences_1_1.value;
+                var influenceCards = allCards.locationId(influence);
+                indexes.push.apply(indexes, __spreadArray([], __read(influenceCards.maxBy(function (item) { return item.location.x; }).getIndexes()), false));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (allInfluences_1_1 && !allInfluences_1_1.done && (_a = allInfluences_1.return)) _a.call(allInfluences_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return allCards.index(indexes).moveItems({
+            type: LocationType_1.LocationType.AgentDiscard
+        });
+    };
+    ExileRule.prototype.exileMultipleCards = function () {
+        var e_2, _a;
+        if (!this.effect.quantities)
+            return [];
+        var allCards = this.cards;
+        var moves = [];
+        try {
+            for (var _b = __values(this.effect.quantities), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var quantity = _c.value;
+                if (allCards.length < quantity)
+                    continue;
+                moves.push(allCards.limit(quantity).moveItemsAtOnce({ type: LocationType_1.LocationType.AgentDiscard }));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return moves;
+    };
+    Object.defineProperty(ExileRule.prototype, "cards", {
+        get: function () {
+            var _this = this;
+            var team = this.effect.opponent ? this.opponentTeam : this.playerHelper.team;
+            return this.material(MaterialType_1.MaterialType.AgentCard)
+                .location(LocationType_1.LocationType.Influence)
+                .filter(function (item) {
+                if (_this.effect.except && _this.effect.except === item.location.id)
+                    return false;
+                if (_this.effect.influence && _this.effect.influence !== item.location.id)
+                    return false;
+                return true;
+            })
+                .player(team)
+                .sort(function (item) { return -item.location.x; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ExileRule;
+}(index_1.EffectRule));
+exports.ExileRule = ExileRule;

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

@@ -0,0 +1,13 @@
+import { CustomMove, ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { GiveCreditEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class GiveCreditRule extends EffectRule<GiveCreditEffect> {
+    onRuleStart(): MaterialMove[];
+    getExtraDataFromMove(move: ItemMove | CustomMove): {
+        quantity?: undefined;
+    } | {
+        quantity: number;
+    };
+    isPossible(): boolean;
+    onRuleEnd(): never[];
+}

package/dist/rules/effect/GiveCreditRule.js

@@ -0,0 +1,79 @@
+"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.GiveCreditRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var GiveCreditRule = (function (_super) {
+    __extends(GiveCreditRule, _super);
+    function GiveCreditRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GiveCreditRule.prototype.onRuleStart = function () {
+        var moves = [];
+        var money = this.creditMoney;
+        this.memorize(Memory_1.Memory.CurrentEffect, JSON.parse(JSON.stringify(this.effect)));
+        this.memorize(Memory_1.Memory.Credit, this.effect.quantity);
+        moves.push.apply(moves, __spreadArray([], __read(money.moveMoney({ type: LocationType_1.LocationType.TeamCredit, player: this.playerHelper.team }, { type: LocationType_1.LocationType.TeamCredit, player: this.opponentTeam }, this.effect.quantity)), false));
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    GiveCreditRule.prototype.getExtraDataFromMove = function (move) {
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.DoCondition)(move))
+            return {};
+        return { quantity: move.data };
+    };
+    GiveCreditRule.prototype.isPossible = function () {
+        return this.playerHelper.credits >= this.effect.quantity;
+    };
+    GiveCreditRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.CurrentEffect);
+        this.forget(Memory_1.Memory.Credit);
+        return [];
+    };
+    return GiveCreditRule;
+}(index_1.EffectRule));
+exports.GiveCreditRule = GiveCreditRule;

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

@@ -0,0 +1,10 @@
+import { Material, MaterialItem, MaterialMove } from '@gamepark/rules-api';
+import { GiveInfluenceEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class GiveInfluenceRule extends EffectRule<GiveInfluenceEffect> {
+    getPlayerMoves(): MaterialMove[];
+    get planets(): Material;
+    isPossible(): boolean;
+    getPositionAfterPush(item: MaterialItem): number;
+    afterItemMove(move: MaterialMove): MaterialMove[];
+}

package/dist/rules/effect/GiveInfluenceRule.js

@@ -0,0 +1,119 @@
+"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.GiveInfluenceRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var TeamColor_1 = require("../../TeamColor");
+var BonusHelper_1 = require("../helper/BonusHelper");
+var EndGameHelper_1 = require("../helper/EndGameHelper");
+var index_1 = require("./index");
+var GiveInfluenceRule = (function (_super) {
+    __extends(GiveInfluenceRule, _super);
+    function GiveInfluenceRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GiveInfluenceRule.prototype.getPlayerMoves = function () {
+        var _this = this;
+        var moves = [];
+        var planets = this.planets;
+        moves.push.apply(moves, __spreadArray([], __read(planets.moveItems(function (item) { return (__assign(__assign({}, item.location), { x: _this.getPositionAfterPush(item) })); })), false));
+        return moves;
+    };
+    Object.defineProperty(GiveInfluenceRule.prototype, "planets", {
+        get: function () {
+            var _this = this;
+            var planets = this.material(MaterialType_1.MaterialType.InfluenceDisc).location(LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace);
+            if (this.effect.except)
+                return planets.filter(function (item) { return item.id !== _this.effect.except; });
+            return planets;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GiveInfluenceRule.prototype.isPossible = function () {
+        return this.getPlayerMoves().length > 0;
+    };
+    GiveInfluenceRule.prototype.getPositionAfterPush = function (item) {
+        if (this.player === TeamColor_1.TeamColor.White) {
+            return Math.min(4, item.location.x + 1);
+        }
+        return Math.max(-4, item.location.x - 1);
+    };
+    GiveInfluenceRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.InfluenceDisc)(move))
+            return [];
+        if (Math.abs(move.location.x) === 4) {
+            var planet = this.material(MaterialType_1.MaterialType.InfluenceDisc).index(move.itemIndex);
+            var helper = new EndGameHelper_1.EndGameHelper(this.game);
+            var moves = [];
+            moves.push.apply(moves, __spreadArray([], __read(planet.moveItems({
+                type: LocationType_1.LocationType.TeamPlanets,
+                player: this.playerHelper.team
+            })), false));
+            if (helper.willEnd(this.playerHelper.team)) {
+                moves.push(this.endGame());
+            }
+            else {
+                var item = planet.getItem();
+                moves.push.apply(moves, __spreadArray([], __read(new BonusHelper_1.BonusHelper(this.game).applyInfluenceBonus(item.id)), false));
+            }
+            return moves;
+        }
+        this.removeFirstEffect();
+        return this.afterEffectPlayed();
+    };
+    return GiveInfluenceRule;
+}(index_1.EffectRule));
+exports.GiveInfluenceRule = GiveInfluenceRule;

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

@@ -0,0 +1,9 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { GiveLeaderBadgeEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class GiveLeaderBadgeRule extends EffectRule<GiveLeaderBadgeEffect> {
+    getPlayerMoves(): MaterialMove[];
+    get leaderBadge(): import("@gamepark/rules-api").Material<number, number, number>;
+    isPossible(): boolean;
+    afterItemMove(move: MaterialMove): MaterialMove[];
+}

package/dist/rules/effect/GiveLeaderBadgeRule.js

@@ -0,0 +1,54 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiveLeaderBadgeRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var index_1 = require("./index");
+var GiveLeaderBadgeRule = (function (_super) {
+    __extends(GiveLeaderBadgeRule, _super);
+    function GiveLeaderBadgeRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GiveLeaderBadgeRule.prototype.getPlayerMoves = function () {
+        var moves = [];
+        moves.push(this.leaderBadge.moveItem({
+            type: LocationType_1.LocationType.TeamLeaderBadge,
+            player: this.opponentTeam
+        }));
+        return moves;
+    };
+    Object.defineProperty(GiveLeaderBadgeRule.prototype, "leaderBadge", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.LeaderBadgeToken);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GiveLeaderBadgeRule.prototype.isPossible = function () {
+        return this.playerHelper.isLeader;
+    };
+    GiveLeaderBadgeRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.InfluenceDisc)(move))
+            return [];
+        this.removeFirstEffect();
+        return this.afterEffectPlayed();
+    };
+    return GiveLeaderBadgeRule;
+}(index_1.EffectRule));
+exports.GiveLeaderBadgeRule = GiveLeaderBadgeRule;

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

@@ -0,0 +1,9 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { GiveZenithiumEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class GiveZenithiumRule extends EffectRule<GiveZenithiumEffect> {
+    onRuleStart(): MaterialMove[];
+    get zenithium(): import("@gamepark/rules-api").Material<number, number, number>;
+    isPossible(): boolean;
+    onRuleEnd(): never[];
+}

package/dist/rules/effect/GiveZenithiumRule.js

@@ -0,0 +1,85 @@
+"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.GiveZenithiumRule = void 0;
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var GiveZenithiumRule = (function (_super) {
+    __extends(GiveZenithiumRule, _super);
+    function GiveZenithiumRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GiveZenithiumRule.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)));
+        this.memorize(Memory_1.Memory.Zenithium, this.effect.quantity);
+        moves.push.apply(moves, __spreadArray([], __read(this.zenithium.moveItems({
+            type: LocationType_1.LocationType.TeamZenithium,
+            player: this.opponentTeam
+        }, this.effect.quantity)), false));
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    Object.defineProperty(GiveZenithiumRule.prototype, "zenithium", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.ZenithiumToken).location(LocationType_1.LocationType.TeamZenithium).player(this.playerHelper.team);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GiveZenithiumRule.prototype.isPossible = function () {
+        var _a;
+        return this.zenithium.getQuantity() >= ((_a = this.effect.quantity) !== null && _a !== void 0 ? _a : 1);
+    };
+    GiveZenithiumRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.CurrentEffect);
+        this.forget(Memory_1.Memory.Zenithium);
+        return [];
+    };
+    return GiveZenithiumRule;
+}(index_1.EffectRule));
+exports.GiveZenithiumRule = GiveZenithiumRule;

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

@@ -0,0 +1,18 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { MobilizeEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class MobilizeRule extends EffectRule<MobilizeEffect> {
+    onRuleStart(): MaterialMove[];
+    getAutomaticEffectMoves(): MaterialMove[];
+    decrement(move: ItemMove): boolean;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    getExtraDataFromMove(move: ItemMove): {
+        quantity: number;
+        influence: import("../../material/Influence").Influence;
+    } | {
+        quantity?: undefined;
+        influence?: undefined;
+    };
+    isPossible(): boolean;
+    get deck(): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
+}