@gamepark/zenith 0.0.1

package/dist/rules/effect/WinInfluenceRule.js

@@ -0,0 +1,328 @@
+"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));
+};
+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.WinInfluenceRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Influence_1 = require("../../material/Influence");
+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 Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var WinInfluenceRule = (function (_super) {
+    __extends(WinInfluenceRule, _super);
+    function WinInfluenceRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WinInfluenceRule.prototype.onRuleStart = function () {
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        if (this.effect.resetDifferentPlanet) {
+            this.forget(Memory_1.Memory.LastPlanetsMoved);
+        }
+        if (this.effect.influence) {
+            return this.getPlayerMoves();
+        }
+        return [];
+    };
+    Object.defineProperty(WinInfluenceRule.prototype, "planets", {
+        get: function () {
+            var _this = this;
+            var planets = this.material(MaterialType_1.MaterialType.InfluenceDisc)
+                .location(LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace)
+                .filter(function (item) {
+                if (_this.effect.except)
+                    return item.id !== _this.effect.except;
+                if (_this.effect.differentPlanet)
+                    return !_this.isAlreadyPlayed(item.id);
+                return true;
+            });
+            if (!planets.length)
+                return planets;
+            if (this.effect.fromCenter) {
+                return this.fromCenterPlanets(planets);
+            }
+            else if (this.effect.opponentSide) {
+                return this.opponentSidePlanets(planets);
+            }
+            else if (this.effect.influence) {
+                return this.influencePlanet(planets);
+            }
+            return planets;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WinInfluenceRule.prototype.patternPlanet = function () {
+        var e_1, _a;
+        var _this = this;
+        var _b;
+        var pattern = this.effect.pattern;
+        var planets = this.planets;
+        var movedPlanets = (_b = this.remind(Memory_1.Memory.Pattern)) !== null && _b !== void 0 ? _b : [];
+        if (!pattern)
+            return [];
+        var moves = [];
+        var possiblePatterns = this.computePossiblePatterns().filter(function (patternType) {
+            if (!movedPlanets.length)
+                return true;
+            return movedPlanets.every(function (m) { return patternType.some(function (p) { return p.influence === m.influence && p.count === m.count; }); });
+        });
+        var _loop_1 = function (planetIndex) {
+            var material = planets.index(planetIndex);
+            var item = planets.getItem(planetIndex);
+            if (movedPlanets.some(function (patternType) { return patternType.influence === item.id; }))
+                return "continue";
+            var planetPossiblePatterns = possiblePatterns
+                .filter(function (patternType) { return patternType.some(function (p) { return p.influence === item.id; }); })
+                .map(function (patternType) { return patternType.find(function (p) { return p.influence === item.id; }); });
+            moves.push.apply(moves, __spreadArray([], __read(planetPossiblePatterns.map(function (type) {
+                return material.moveItem(__assign(__assign({}, item.location), { x: _this.getPositionForQuantity(item, type.count) }));
+            })), false));
+        };
+        try {
+            for (var _c = __values(planets.getIndexes()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var planetIndex = _d.value;
+                _loop_1(planetIndex);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    WinInfluenceRule.prototype.computePossiblePatterns = function () {
+        var pattern = this.effect.pattern;
+        if (!pattern)
+            return [];
+        var patterns = [];
+        for (var i = 1; i <= Influence_1.influences.length - (pattern.length - 1); i++) {
+            var patternInfluences = Influence_1.influences.slice(i - 1, i + pattern.length - 1);
+            patterns.push(patternInfluences.map(function (i, index) { return ({ influence: i, count: pattern[index] }); }));
+        }
+        return patterns;
+    };
+    WinInfluenceRule.prototype.influencePlanet = function (planets) {
+        return planets.id(this.effect.influence);
+    };
+    WinInfluenceRule.prototype.opponentSidePlanets = function (planets) {
+        var _this = this;
+        var opponentSidePlanets = planets.filter(function (planet) { return (_this.playerHelper.team === TeamColor_1.TeamColor.White ? planet.location.x < 0 : planet.location.x > 0); });
+        if (!opponentSidePlanets.length)
+            return opponentSidePlanets;
+        if (this.effect.influence)
+            return opponentSidePlanets.id(this.effect.influence);
+        return opponentSidePlanets;
+    };
+    WinInfluenceRule.prototype.fromCenterPlanets = function (planets) {
+        var centeredPlanets = planets.filter(function (planet) { return planet.location.x === 0; });
+        if (!centeredPlanets.length)
+            return centeredPlanets;
+        if (this.effect.influence)
+            return centeredPlanets.id(this.effect.influence);
+        return centeredPlanets;
+    };
+    WinInfluenceRule.prototype.getPositionAfterPull = function (item, effect) {
+        var _a;
+        if (effect.times) {
+            var positions = [];
+            for (var i = 1; i <= effect.times; i++) {
+                var newPosition = item.location.x + i;
+                if (this.player === TeamColor_1.TeamColor.Black && newPosition > 4)
+                    break;
+                if (this.player === TeamColor_1.TeamColor.White && newPosition < -4)
+                    break;
+                positions.push(newPosition);
+            }
+            return positions;
+        }
+        return [this.getPositionForQuantity(item, (_a = effect.quantity) !== null && _a !== void 0 ? _a : 1)];
+    };
+    WinInfluenceRule.prototype.getPositionForQuantity = function (item, quantity) {
+        if (this.player === TeamColor_1.TeamColor.Black) {
+            return Math.min(4, item.location.x + quantity);
+        }
+        return Math.max(-4, item.location.x - quantity);
+    };
+    WinInfluenceRule.prototype.getPlayerMoves = function () {
+        var e_2, _a;
+        var effect = this.effect;
+        var planets = this.planets;
+        if (this.effect.pattern) {
+            return this.patternPlanet();
+        }
+        var moves = [];
+        var _loop_2 = function (index) {
+            var item = planets.getItem(index);
+            var positions = this_1.getPositionAfterPull(item, effect);
+            moves.push.apply(moves, __spreadArray([], __read(positions.map(function (x) {
+                return planets.index(index).moveItem(__assign(__assign({}, item.location), { x: x }));
+            })), false));
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(planets.getIndexes()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var index = _c.value;
+                _loop_2(index);
+            }
+        }
+        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;
+    };
+    WinInfluenceRule.prototype.beforeItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.InfluenceDisc)(move) || move.location.type !== LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace)
+            return [];
+        var planet = this.material(MaterialType_1.MaterialType.InfluenceDisc).index(move.itemIndex);
+        var item = planet.getItem();
+        this.memorize(Memory_1.Memory.LastPlanetsMoved, function (planets) {
+            if (planets === void 0) { planets = []; }
+            return planets.concat(item.id);
+        });
+        var moves = [];
+        var effect = this.effect;
+        if (Math.abs(move.location.x) === 4) {
+            var helper = new EndGameHelper_1.EndGameHelper(this.game);
+            var planets = this.material(MaterialType_1.MaterialType.InfluenceDisc).index(__spreadArray(__spreadArray([], __read(helper.getTeamPlanet(this.playerHelper.team).getIndexes()), false), [planet.getIndex()], false));
+            moves.push.apply(moves, __spreadArray([], __read(planet.moveItems({
+                type: LocationType_1.LocationType.TeamPlanets,
+                player: this.playerHelper.team
+            })), false));
+            if (helper.willEnd(this.playerHelper.team, planets)) {
+                moves.push(this.endGame());
+                return moves;
+            }
+            else {
+                moves.push.apply(moves, __spreadArray([], __read(new BonusHelper_1.BonusHelper(this.game).applyInfluenceBonus(item.id)), false));
+            }
+        }
+        if (effect.times) {
+            var consumed = move.location.x - item.location.x;
+            effect.times -= consumed;
+            if (effect.times > 0)
+                return moves;
+        }
+        else if (effect.pattern) {
+            this.memorize(Memory_1.Memory.Pattern, function (patternTypes) {
+                if (patternTypes === void 0) { patternTypes = []; }
+                return patternTypes.concat({ influence: item.id, count: Math.abs(move.location.x - item.location.x) });
+            });
+            var patternMoves = this.patternPlanet();
+            if (patternMoves.length > 0 && patternMoves.length <= effect.pattern.length - 1) {
+                moves.push(this.patternPlanet()[0]);
+                return moves;
+            }
+            if (patternMoves.length > 0)
+                return moves;
+        }
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    WinInfluenceRule.prototype.isAlreadyPlayed = function (influence) {
+        var _a;
+        return (_a = this.lastPlanetsMoved) === null || _a === void 0 ? void 0 : _a.includes(influence);
+    };
+    WinInfluenceRule.prototype.isPossible = function () {
+        return this.planets.length > 0;
+    };
+    Object.defineProperty(WinInfluenceRule.prototype, "lastPlanetsMoved", {
+        get: function () {
+            return this.remind(Memory_1.Memory.LastPlanetsMoved);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WinInfluenceRule.prototype.setExtraData = function (_extraData) {
+        var _a, _b;
+        var _c, _d;
+        if (_extraData.quantity) {
+            (_a = (_c = this.effect).quantity) !== null && _a !== void 0 ? _a : (_c.quantity = _extraData.quantity);
+        }
+        if (_extraData.factor) {
+            this.effect.times = _extraData.factor;
+        }
+        if (_extraData.influence) {
+            (_b = (_d = this.effect).influence) !== null && _b !== void 0 ? _b : (_d.influence = _extraData.influence);
+        }
+    };
+    WinInfluenceRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.Pattern);
+        return [];
+    };
+    return WinInfluenceRule;
+}(index_1.EffectRule));
+exports.WinInfluenceRule = WinInfluenceRule;

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

@@ -0,0 +1,9 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { WinZenithiumEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class WinZenithiumRule extends EffectRule<WinZenithiumEffect> {
+    onRuleStart(): MaterialMove[];
+    setExtraData(_extraData: Record<string, unknown>): void;
+    get zenithium(): import("@gamepark/rules-api").Material<number, number, number>;
+    onRuleEnd(): never[];
+}

package/dist/rules/effect/WinZenithiumRule.js

@@ -0,0 +1,92 @@
+"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.WinZenithiumRule = 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 WinZenithiumRule = (function (_super) {
+    __extends(WinZenithiumRule, _super);
+    function WinZenithiumRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WinZenithiumRule.prototype.onRuleStart = function () {
+        var _a, _b;
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        this.memorize(Memory_1.Memory.Zenithium, (_a = this.effect.quantity) !== null && _a !== void 0 ? _a : 1);
+        this.memorize(Memory_1.Memory.CurrentEffect, JSON.parse(JSON.stringify(this.effect)));
+        moves.push(this.zenithium.createItem({
+            location: {
+                type: LocationType_1.LocationType.TeamZenithium,
+                player: this.effect.opponent ? this.opponentTeam : this.playerHelper.team
+            },
+            quantity: (_b = this.effect.quantity) !== null && _b !== void 0 ? _b : 1
+        }));
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    WinZenithiumRule.prototype.setExtraData = function (_extraData) {
+        var _a;
+        var _b;
+        if (_extraData.quantity) {
+            (_a = (_b = this.effect).quantity) !== null && _a !== void 0 ? _a : (_b.quantity = _extraData.quantity);
+        }
+    };
+    Object.defineProperty(WinZenithiumRule.prototype, "zenithium", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.ZenithiumToken).location(LocationType_1.LocationType.TeamZenithium).player(this.playerHelper.team);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WinZenithiumRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.Zenithium);
+        this.forget(Memory_1.Memory.CurrentEffect);
+        return [];
+    };
+    return WinZenithiumRule;
+}(index_1.EffectRule));
+exports.WinZenithiumRule = WinZenithiumRule;

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

@@ -0,0 +1,19 @@
+export * from './EffectRule';
+export * from './ChoiceRule';
+export * from './ConditionalRule';
+export * from './DevelopTechnologyRule';
+export * from './DiscardRule';
+export * from './ExileRule';
+export * from './GiveCreditRule';
+export * from './GiveInfluenceRule';
+export * from './GiveLeaderBadgeRule';
+export * from './GiveZenithiumRule';
+export * from './MobilizeRule';
+export * from './ResetInfluenceRule';
+export * from './SpendCreditRule';
+export * from './TakeBonusRule';
+export * from './TakeLeaderBadgeRule';
+export * from './TransferRule';
+export * from './WinCreditRule';
+export * from './WinInfluenceRule';
+export * from './WinZenithiumRule';

package/dist/rules/effect/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EffectRule"), exports);
+__exportStar(require("./ChoiceRule"), exports);
+__exportStar(require("./ConditionalRule"), exports);
+__exportStar(require("./DevelopTechnologyRule"), exports);
+__exportStar(require("./DiscardRule"), exports);
+__exportStar(require("./ExileRule"), exports);
+__exportStar(require("./GiveCreditRule"), exports);
+__exportStar(require("./GiveInfluenceRule"), exports);
+__exportStar(require("./GiveLeaderBadgeRule"), exports);
+__exportStar(require("./GiveZenithiumRule"), exports);
+__exportStar(require("./MobilizeRule"), exports);
+__exportStar(require("./ResetInfluenceRule"), exports);
+__exportStar(require("./SpendCreditRule"), exports);
+__exportStar(require("./TakeBonusRule"), exports);
+__exportStar(require("./TakeLeaderBadgeRule"), exports);
+__exportStar(require("./TransferRule"), exports);
+__exportStar(require("./WinCreditRule"), exports);
+__exportStar(require("./WinInfluenceRule"), exports);
+__exportStar(require("./WinZenithiumRule"), exports);

package/dist/rules/helper/BonusHelper.d.ts

@@ -0,0 +1,15 @@
+import { Material, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+import { Bonus } from '../../material/Bonus';
+import { Effect } from '../../material/effect/Effect';
+import { Influence } from '../../material/Influence';
+export type TechnologyBonusResult = {
+    effect: Effect;
+    moves: MaterialMove[];
+    bonusId: Bonus;
+};
+export declare class BonusHelper extends MaterialRulesPart {
+    applyInfluenceBonus(influence: Influence): MaterialMove[];
+    getTechnologyBonus(token: Material): TechnologyBonusResult | undefined;
+    applyBonusEffect(bonusToken: Material): MaterialMove[];
+    getBonusEffect(bonusToken: Material): Effect | undefined;
+}

package/dist/rules/helper/BonusHelper.js

@@ -0,0 +1,86 @@
+"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.BonusHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Bonuses_1 = require("../../material/Bonuses");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../Memory");
+var BonusHelper = (function (_super) {
+    __extends(BonusHelper, _super);
+    function BonusHelper() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BonusHelper.prototype.applyInfluenceBonus = function (influence) {
+        var bonusToken = this.material(MaterialType_1.MaterialType.BonusToken).location(LocationType_1.LocationType.PlanetBoardBonusSpace).locationId(influence);
+        return this.applyBonusEffect(bonusToken);
+    };
+    BonusHelper.prototype.getTechnologyBonus = function (token) {
+        var tokenItem = token.getItem();
+        if (tokenItem.location.x !== 2)
+            return;
+        var bonusToken = this.material(MaterialType_1.MaterialType.BonusToken).location(LocationType_1.LocationType.TechnologyBoardBonusSpace).parent(tokenItem.location.parent);
+        if (!bonusToken.length)
+            return;
+        return {
+            effect: this.getBonusEffect(bonusToken),
+            moves: [
+                bonusToken.moveItem({
+                    type: LocationType_1.LocationType.BonusDiscard
+                })
+            ],
+            bonusId: bonusToken.getItem().id
+        };
+    };
+    BonusHelper.prototype.applyBonusEffect = function (bonusToken) {
+        var moves = [];
+        var bonusEffect = this.getBonusEffect(bonusToken);
+        if (bonusEffect) {
+            moves.push(bonusToken.moveItem({
+                type: LocationType_1.LocationType.BonusDiscard
+            }));
+            var effects = this.remind(Memory_1.Memory.Effects);
+            effects.splice(1, 0, __assign(__assign({}, bonusEffect), { effectSource: {
+                    type: MaterialType_1.MaterialType.BonusToken,
+                    value: bonusToken.getItem().id
+                } }));
+        }
+        return moves;
+    };
+    BonusHelper.prototype.getBonusEffect = function (bonusToken) {
+        if (bonusToken.length) {
+            var bonusItem = bonusToken.getItem();
+            var bonusId = bonusItem.id;
+            return JSON.parse(JSON.stringify(Bonuses_1.Bonuses[bonusId].effect));
+        }
+        return;
+    };
+    return BonusHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.BonusHelper = BonusHelper;

package/dist/rules/helper/CreditHelper.d.ts

@@ -0,0 +1,9 @@
+import { MaterialGame, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerId } from '../../PlayerId';
+export declare class CreditHelper extends MaterialRulesPart {
+    readonly player: PlayerId;
+    private playerHelper;
+    constructor(game: MaterialGame, player: PlayerId);
+    get creditMoney(): import("@gamepark/rules-api").MaterialMoney<number, number, number, import("../../material/Credit").Credit>;
+    spendCredit(count?: number): MaterialMove[];
+}

package/dist/rules/helper/CreditHelper.js

@@ -0,0 +1,45 @@
+"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.CreditHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Credit_1 = require("../../material/Credit");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var PlayerHelper_1 = require("./PlayerHelper");
+var CreditHelper = (function (_super) {
+    __extends(CreditHelper, _super);
+    function CreditHelper(game, player) {
+        var _this = _super.call(this, game) || this;
+        _this.player = player;
+        _this.playerHelper = new PlayerHelper_1.PlayerHelper(game, player);
+        return _this;
+    }
+    Object.defineProperty(CreditHelper.prototype, "creditMoney", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.CreditToken).money(Credit_1.credits);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CreditHelper.prototype.spendCredit = function (count) {
+        if (count === void 0) { count = 1; }
+        return this.creditMoney.removeMoney(count, { type: LocationType_1.LocationType.TeamCredit, player: this.playerHelper.team });
+    };
+    return CreditHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.CreditHelper = CreditHelper;

package/dist/rules/helper/EffectHelper.d.ts

@@ -0,0 +1,16 @@
+import { MaterialGame, MaterialItem, MaterialRulesPart } from '@gamepark/rules-api';
+import { Effect, ExpandedEffect } from '../../material/effect/Effect';
+import { EffectType } from '../../material/effect/EffectType';
+import { PlayerId } from '../../PlayerId';
+import { EffectRule } from '../effect';
+import { RuleId } from '../RuleId';
+export declare class EffectHelper extends MaterialRulesPart {
+    readonly player: PlayerId;
+    constructor(game: MaterialGame, player: PlayerId);
+    applyCard(item: MaterialItem): import("@gamepark/rules-api").StartRule<RuleId>[];
+    applyFirstEffect(): import("@gamepark/rules-api").StartRule<RuleId>[];
+    get effect(): Effect | undefined;
+    get effects(): ExpandedEffect[];
+    get effectRuleIds(): Record<EffectType, RuleId>;
+}
+export declare const getEffectRule: (game: MaterialGame, effect: Effect) => EffectRule;