@gamepark/zenith 0.0.1

package/dist/rules/effect/MobilizeRule.js

@@ -0,0 +1,117 @@
+"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.MobilizeRule = 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 index_1 = require("./index");
+var MobilizeRule = (function (_super) {
+    __extends(MobilizeRule, _super);
+    function MobilizeRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MobilizeRule.prototype.onRuleStart = function () {
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        return this.getAutomaticEffectMoves();
+    };
+    MobilizeRule.prototype.getAutomaticEffectMoves = function () {
+        var _this = this;
+        var _a, _b;
+        var moves = [];
+        var agent = this.material(MaterialType_1.MaterialType.AgentCard)
+            .location(LocationType_1.LocationType.AgentDeck)
+            .deck()
+            .limit((_a = this.effect.quantity) !== null && _a !== void 0 ? _a : 1);
+        if (!agent.length || !((_b = agent.getItem()) === null || _b === void 0 ? void 0 : _b.id))
+            return [];
+        moves.push.apply(moves, __spreadArray([], __read(agent.moveItems(function (item) { return ({
+            type: LocationType_1.LocationType.Influence,
+            id: Agents_1.Agents[item.id].influence,
+            player: _this.playerHelper.team
+        }); })), false));
+        return moves;
+    };
+    MobilizeRule.prototype.decrement = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) || move.location.type !== LocationType_1.LocationType.Influence)
+            return false;
+        if (this.effect.quantity) {
+            this.effect.quantity--;
+            return this.effect.quantity === 0;
+        }
+        return true;
+    };
+    MobilizeRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) || move.location.type !== LocationType_1.LocationType.Influence)
+            return [];
+        if (this.effect.quantity) {
+            this.effect.quantity--;
+        }
+        if (!this.effect.quantity) {
+            this.removeFirstEffect();
+            return this.afterEffectPlayed();
+        }
+        return [];
+    };
+    MobilizeRule.prototype.getExtraDataFromMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.Influence) {
+            var card = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
+            return { quantity: Agents_1.Agents[card.id].cost, influence: Agents_1.Agents[card.id].influence };
+        }
+        return {};
+    };
+    MobilizeRule.prototype.isPossible = function () {
+        return this.deck.length > 0;
+    };
+    Object.defineProperty(MobilizeRule.prototype, "deck", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MobilizeRule;
+}(index_1.EffectRule));
+exports.MobilizeRule = MobilizeRule;

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

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

package/dist/rules/effect/ResetInfluenceRule.js

@@ -0,0 +1,63 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetInfluenceRule = 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 index_1 = require("./index");
+var ResetInfluenceRule = (function (_super) {
+    __extends(ResetInfluenceRule, _super);
+    function ResetInfluenceRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ResetInfluenceRule.prototype.getPlayerMoves = function () {
+        var planets = this.planets;
+        return planets.moveItems(function (item) { return (__assign(__assign({}, item.location), { x: 0 })); });
+    };
+    ResetInfluenceRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.InfluenceDisc)(move) || move.location.x !== 0)
+            return [];
+        this.removeFirstEffect();
+        return this.afterEffectPlayed();
+    };
+    ResetInfluenceRule.prototype.isPossible = function () {
+        return this.planets.length > 0;
+    };
+    Object.defineProperty(ResetInfluenceRule.prototype, "planets", {
+        get: function () {
+            var _this = this;
+            return this.material(MaterialType_1.MaterialType.InfluenceDisc).location(function (l) { return l.type === LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace && (_this.playerHelper.team === TeamColor_1.TeamColor.White ? l.x < 0 : l.x > 0); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ResetInfluenceRule;
+}(index_1.EffectRule));
+exports.ResetInfluenceRule = ResetInfluenceRule;

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

@@ -0,0 +1,16 @@
+import { CustomMove, ItemMove, MaterialMove } 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 { SpendCreditEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class SpendCreditRule extends EffectRule<SpendCreditEffect> {
+    onRuleStart(_move: RuleMove, _previousRule?: RuleStep, _context?: PlayMoveContext): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    getExtraDataFromMove(move: ItemMove | CustomMove): {
+        factor?: undefined;
+    } | {
+        factor: number;
+    };
+    isPossible(): boolean;
+}

package/dist/rules/effect/SpendCreditRule.js

@@ -0,0 +1,109 @@
+"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));
+};
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpendCreditRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var index_1 = require("./index");
+var SpendCreditRule = (function (_super) {
+    __extends(SpendCreditRule, _super);
+    function SpendCreditRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpendCreditRule.prototype.onRuleStart = function (_move, _previousRule, _context) {
+        var cost = this.effect.quantity;
+        var money = this.creditMoney;
+        var moves = money.removeMoney(cost, { type: LocationType_1.LocationType.TeamCredit, player: this.playerHelper.team });
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    SpendCreditRule.prototype.getPlayerMoves = function () {
+        var e_1, _a;
+        var credits = this.playerHelper.credits;
+        var effect = this.effect;
+        var moves = [];
+        try {
+            for (var _b = __values(effect.quantities), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var quantity = _c.value;
+                if (credits < quantity)
+                    continue;
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.DoCondition, quantity));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    SpendCreditRule.prototype.getExtraDataFromMove = function (move) {
+        var _a;
+        var _b;
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.DoCondition)(move))
+            return {};
+        var quantity = move.data;
+        (_a = (_b = this.effect).quantity) !== null && _a !== void 0 ? _a : (_b.quantity = quantity);
+        var index = this.effect.quantities.indexOf(quantity);
+        return { factor: this.effect.factors[index] };
+    };
+    SpendCreditRule.prototype.isPossible = function () {
+        return this.getPlayerMoves().length > 0;
+    };
+    return SpendCreditRule;
+}(index_1.EffectRule));
+exports.SpendCreditRule = SpendCreditRule;

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

@@ -0,0 +1,17 @@
+import { CustomMove, ItemMove, MaterialMove } 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 { SpendZenithiumEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class SpendZenithiumRule extends EffectRule<SpendZenithiumEffect> {
+    onRuleStart(_move: RuleMove, _previousRule?: RuleStep, _context?: PlayMoveContext): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    get zenithium(): import("@gamepark/rules-api").Material<number, number, number>;
+    getExtraDataFromMove(move: ItemMove | CustomMove): {
+        factor?: undefined;
+    } | {
+        factor: number;
+    };
+    isPossible(): boolean;
+}

package/dist/rules/effect/SpendZenithiumRule.js

@@ -0,0 +1,116 @@
+"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));
+};
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpendZenithiumRule = 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 index_1 = require("./index");
+var SpendZenithiumRule = (function (_super) {
+    __extends(SpendZenithiumRule, _super);
+    function SpendZenithiumRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpendZenithiumRule.prototype.onRuleStart = function (_move, _previousRule, _context) {
+        var cost = this.effect.quantity;
+        var moves = [this.zenithium.deleteItem(cost)];
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    SpendZenithiumRule.prototype.getPlayerMoves = function () {
+        var e_1, _a;
+        var zenithium = this.playerHelper.zenithium;
+        var effect = this.effect;
+        var moves = [];
+        try {
+            for (var _b = __values(effect.quantities), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var quantity = _c.value;
+                if (zenithium < quantity)
+                    continue;
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.DoCondition, quantity));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    Object.defineProperty(SpendZenithiumRule.prototype, "zenithium", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.ZenithiumToken).location(LocationType_1.LocationType.TeamZenithium).player(this.playerHelper.team);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SpendZenithiumRule.prototype.getExtraDataFromMove = function (move) {
+        var _a;
+        var _b;
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.DoCondition)(move))
+            return {};
+        var quantity = move.data;
+        (_a = (_b = this.effect).quantity) !== null && _a !== void 0 ? _a : (_b.quantity = quantity);
+        var index = this.effect.quantities.indexOf(quantity);
+        return { factor: this.effect.factors[index] };
+    };
+    SpendZenithiumRule.prototype.isPossible = function () {
+        return this.getPlayerMoves().length > 0;
+    };
+    return SpendZenithiumRule;
+}(index_1.EffectRule));
+exports.SpendZenithiumRule = SpendZenithiumRule;

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

@@ -0,0 +1,7 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { StealCreditEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class StealCreditRule extends EffectRule<StealCreditEffect> {
+    onRuleStart(): MaterialMove[];
+    isPossible(): boolean;
+}

package/dist/rules/effect/StealCreditRule.js

@@ -0,0 +1,67 @@
+"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.StealCreditRule = void 0;
+var Credit_1 = require("../../material/Credit");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var index_1 = require("./index");
+var StealCreditRule = (function (_super) {
+    __extends(StealCreditRule, _super);
+    function StealCreditRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StealCreditRule.prototype.onRuleStart = function () {
+        var moves = [];
+        var money = this.creditMoney;
+        moves.push.apply(moves, __spreadArray([], __read(money.moveMoney({ type: LocationType_1.LocationType.TeamCredit, player: this.opponentTeam }, { type: LocationType_1.LocationType.TeamCredit, player: this.playerHelper.team }, this.effect.quantity)), false));
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    StealCreditRule.prototype.isPossible = function () {
+        var opponentCredits = this.material(MaterialType_1.MaterialType.CreditToken).money(Credit_1.credits).player(this.opponentTeam).count;
+        return opponentCredits >= this.effect.quantity;
+    };
+    return StealCreditRule;
+}(index_1.EffectRule));
+exports.StealCreditRule = StealCreditRule;

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

@@ -0,0 +1,11 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { TakeBonusEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class TakeBonusRule extends EffectRule<TakeBonusEffect> {
+    getPlayerMoves(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    get bonusTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    isPossible(): boolean;
+    get visibleBonusToken(): import("@gamepark/rules-api").Material<number, number, number>;
+    get reserveBonusToken(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effect/TakeBonusRule.js

@@ -0,0 +1,98 @@
+"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.TakeBonusRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var BonusHelper_1 = require("../helper/BonusHelper");
+var index_1 = require("./index");
+var TakeBonusRule = (function (_super) {
+    __extends(TakeBonusRule, _super);
+    function TakeBonusRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TakeBonusRule.prototype.getPlayerMoves = function () {
+        return this.bonusTokens.moveItems({
+            type: LocationType_1.LocationType.BonusDiscard
+        });
+    };
+    Object.defineProperty(TakeBonusRule.prototype, "bonusTokens", {
+        get: function () {
+            if (this.effect.visible) {
+                return this.visibleBonusToken;
+            }
+            return this.reserveBonusToken;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TakeBonusRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.BonusToken)(move) || move.location.type !== LocationType_1.LocationType.BonusDiscard)
+            return [];
+        var bonusToken = this.material(MaterialType_1.MaterialType.BonusToken).index(move.itemIndex);
+        var moves = [];
+        new BonusHelper_1.BonusHelper(this.game).applyBonusEffect(bonusToken);
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.applyFirstEffect()), false));
+        return moves;
+    };
+    TakeBonusRule.prototype.isPossible = function () {
+        return this.bonusTokens.length > 0;
+    };
+    Object.defineProperty(TakeBonusRule.prototype, "visibleBonusToken", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.BonusToken).location(function (l) { return l.type === LocationType_1.LocationType.PlanetBoardBonusSpace || l.type === LocationType_1.LocationType.TechnologyBoardBonusSpace; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TakeBonusRule.prototype, "reserveBonusToken", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.BonusToken).location(LocationType_1.LocationType.BonusTokenStock);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TakeBonusRule;
+}(index_1.EffectRule));
+exports.TakeBonusRule = TakeBonusRule;

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

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