@gamepark/zenith 0.0.1

package/dist/rules/helper/EffectHelper.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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEffectRule = exports.EffectHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Agents_1 = require("../../material/Agents");
+var EffectType_1 = require("../../material/effect/EffectType");
+var MaterialType_1 = require("../../material/MaterialType");
+var effect_1 = require("../effect");
+var SpendZenithiumRule_1 = require("../effect/SpendZenithiumRule");
+var StealCreditRule_1 = require("../effect/StealCreditRule");
+var TakeTechnologyBonusTokenRule_1 = require("../effect/TakeTechnologyBonusTokenRule");
+var Memory_1 = require("../Memory");
+var EffectRuleIds_1 = require("./EffectRuleIds");
+var EffectHelper = (function (_super) {
+    __extends(EffectHelper, _super);
+    function EffectHelper(game, player) {
+        var _this = _super.call(this, game) || this;
+        _this.player = player;
+        return _this;
+    }
+    EffectHelper.prototype.applyCard = function (item) {
+        var agent = Agents_1.Agents[item.id];
+        this.memorize(Memory_1.Memory.Effects, JSON.parse(JSON.stringify(agent.effects.map(function (e) { return (__assign(__assign({}, e), { effectSource: {
+                type: MaterialType_1.MaterialType.AgentCard,
+                value: item.id
+            } })); }))));
+        return this.applyFirstEffect();
+    };
+    EffectHelper.prototype.applyFirstEffect = function () {
+        var effect = this.effect;
+        if (!effect) {
+            return [];
+        }
+        return [this.startRule(this.effectRuleIds[effect.type])];
+    };
+    Object.defineProperty(EffectHelper.prototype, "effect", {
+        get: function () {
+            var effects = this.effects;
+            return effects[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EffectHelper.prototype, "effects", {
+        get: function () {
+            return this.remind(Memory_1.Memory.Effects);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EffectHelper.prototype, "effectRuleIds", {
+        get: function () {
+            return EffectRuleIds_1.EffectRuleIds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return EffectHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.EffectHelper = EffectHelper;
+var getEffectRule = function (game, effect) {
+    switch (effect.type) {
+        case EffectType_1.EffectType.ResetInfluence:
+            return new effect_1.ResetInfluenceRule(game, effect);
+        case EffectType_1.EffectType.WinCredit:
+            return new effect_1.WinCreditRule(game, effect);
+        case EffectType_1.EffectType.SpendCredit:
+            return new effect_1.SpendCreditRule(game, effect);
+        case EffectType_1.EffectType.WinZenithium:
+            return new effect_1.WinZenithiumRule(game, effect);
+        case EffectType_1.EffectType.GiveZenithium:
+            return new effect_1.GiveZenithiumRule(game, effect);
+        case EffectType_1.EffectType.Exile:
+            return new effect_1.ExileRule(game, effect);
+        case EffectType_1.EffectType.DevelopTechnology:
+            return new effect_1.DevelopTechnologyRule(game, effect);
+        case EffectType_1.EffectType.GiveLeaderBadge:
+            return new effect_1.GiveLeaderBadgeRule(game, effect);
+        case EffectType_1.EffectType.TakeLeaderBadge:
+            return new effect_1.TakeLeaderBadgeRule(game, effect);
+        case EffectType_1.EffectType.Discard:
+            return new effect_1.DiscardRule(game, effect);
+        case EffectType_1.EffectType.Mobilize:
+            return new effect_1.MobilizeRule(game, effect);
+        case EffectType_1.EffectType.Choice:
+            return new effect_1.ChoiceRule(game, effect);
+        case EffectType_1.EffectType.TakeBonus:
+            return new effect_1.TakeBonusRule(game, effect);
+        case EffectType_1.EffectType.GiveInfluence:
+            return new effect_1.GiveInfluenceRule(game, effect);
+        case EffectType_1.EffectType.WinInfluence:
+            return new effect_1.WinInfluenceRule(game, effect);
+        case EffectType_1.EffectType.Conditional:
+            return new effect_1.ConditionalRule(game, effect);
+        case EffectType_1.EffectType.Transfer:
+            return new effect_1.TransferRule(game, effect);
+        case EffectType_1.EffectType.GiveCredit:
+            return new effect_1.GiveCreditRule(game, effect);
+        case EffectType_1.EffectType.StealCredit:
+            return new StealCreditRule_1.StealCreditRule(game, effect);
+        case EffectType_1.EffectType.SpendZenithium:
+            return new SpendZenithiumRule_1.SpendZenithiumRule(game, effect);
+        case EffectType_1.EffectType.TakeTechnologyBonusToken:
+            return new TakeTechnologyBonusTokenRule_1.TakeTechnologyBonusTokenRule(game, effect);
+    }
+};
+exports.getEffectRule = getEffectRule;

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

@@ -0,0 +1,3 @@
+import { EffectType } from '../../material/effect/EffectType';
+import { RuleId } from '../RuleId';
+export declare const EffectRuleIds: Record<EffectType, RuleId>;

package/dist/rules/helper/EffectRuleIds.js

@@ -0,0 +1,29 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectRuleIds = void 0;
+var EffectType_1 = require("../../material/effect/EffectType");
+var RuleId_1 = require("../RuleId");
+exports.EffectRuleIds = (_a = {},
+    _a[EffectType_1.EffectType.Transfer] = RuleId_1.RuleId.Transfer,
+    _a[EffectType_1.EffectType.GiveCredit] = RuleId_1.RuleId.GiveCredit,
+    _a[EffectType_1.EffectType.WinCredit] = RuleId_1.RuleId.WinCredit,
+    _a[EffectType_1.EffectType.SpendCredit] = RuleId_1.RuleId.SpendCredit,
+    _a[EffectType_1.EffectType.Conditional] = RuleId_1.RuleId.Conditional,
+    _a[EffectType_1.EffectType.WinZenithium] = RuleId_1.RuleId.WinZenithium,
+    _a[EffectType_1.EffectType.GiveZenithium] = RuleId_1.RuleId.GiveZenithium,
+    _a[EffectType_1.EffectType.Exile] = RuleId_1.RuleId.Exile,
+    _a[EffectType_1.EffectType.WinInfluence] = RuleId_1.RuleId.WinInfluence,
+    _a[EffectType_1.EffectType.GiveInfluence] = RuleId_1.RuleId.GiveInfluence,
+    _a[EffectType_1.EffectType.ResetInfluence] = RuleId_1.RuleId.ResetInfluence,
+    _a[EffectType_1.EffectType.DevelopTechnology] = RuleId_1.RuleId.DevelopTechnology,
+    _a[EffectType_1.EffectType.GiveLeaderBadge] = RuleId_1.RuleId.GiveLeaderBadge,
+    _a[EffectType_1.EffectType.TakeLeaderBadge] = RuleId_1.RuleId.TakeLeaderBadge,
+    _a[EffectType_1.EffectType.Discard] = RuleId_1.RuleId.Discard,
+    _a[EffectType_1.EffectType.Mobilize] = RuleId_1.RuleId.Mobilize,
+    _a[EffectType_1.EffectType.Choice] = RuleId_1.RuleId.Choice,
+    _a[EffectType_1.EffectType.TakeBonus] = RuleId_1.RuleId.TakeBonus,
+    _a[EffectType_1.EffectType.StealCredit] = RuleId_1.RuleId.StealCredit,
+    _a[EffectType_1.EffectType.SpendZenithium] = RuleId_1.RuleId.SpendZenithium,
+    _a[EffectType_1.EffectType.TakeTechnologyBonusToken] = RuleId_1.RuleId.TakeTechnologyBonusToken,
+    _a);

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

@@ -0,0 +1,13 @@
+import { Material, MaterialRulesPart } from '@gamepark/rules-api';
+import { Influence } from '../../material/Influence';
+import { TeamColor } from '../../TeamColor';
+export declare class EndGameHelper extends MaterialRulesPart {
+    willEnd(team: TeamColor, planets?: Material<number, number, number>): boolean;
+    get winningTeam(): TeamColor | undefined;
+    getTeamPlanet(team: TeamColor): Material<number, number, number>;
+    getCountDifferentInfluence(planets: Material): number;
+    getMaxSameInfluence(planets: Material): {
+        influence: Influence;
+        count: number;
+    } | undefined;
+}

package/dist/rules/helper/EndGameHelper.js

@@ -0,0 +1,70 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndGameHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var lodash_1 = require("lodash");
+var maxBy_1 = __importDefault(require("lodash/maxBy"));
+var Influence_1 = require("../../material/Influence");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var TeamColor_1 = require("../../TeamColor");
+var EndGameHelper = (function (_super) {
+    __extends(EndGameHelper, _super);
+    function EndGameHelper() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EndGameHelper.prototype.willEnd = function (team, planets) {
+        if (planets === void 0) { planets = this.getTeamPlanet(team); }
+        if (planets.length === 5)
+            return true;
+        var maxSameInfluence = this.getMaxSameInfluence(planets);
+        if (maxSameInfluence && maxSameInfluence.count >= 3)
+            return true;
+        if (this.getCountDifferentInfluence(planets) >= 4)
+            return true;
+        return false;
+    };
+    Object.defineProperty(EndGameHelper.prototype, "winningTeam", {
+        get: function () {
+            var _this = this;
+            return TeamColor_1.teamColors.find(function (team) { return _this.willEnd(team); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EndGameHelper.prototype.getTeamPlanet = function (team) {
+        return this.material(MaterialType_1.MaterialType.InfluenceDisc).location(LocationType_1.LocationType.TeamPlanets).player(team);
+    };
+    EndGameHelper.prototype.getCountDifferentInfluence = function (planets) {
+        return (0, lodash_1.uniqBy)(planets.getItems(), function (item) { return item.id; }).length;
+    };
+    EndGameHelper.prototype.getMaxSameInfluence = function (planets) {
+        var maxInfluence = (0, maxBy_1.default)(Influence_1.influences, function (i) { return planets.id(i).length; });
+        if (!maxInfluence)
+            return;
+        return {
+            influence: maxInfluence,
+            count: planets.id(maxInfluence).length
+        };
+    };
+    return EndGameHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.EndGameHelper = EndGameHelper;

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

@@ -0,0 +1,13 @@
+import { MaterialGame, MaterialItem, MaterialRulesPart } from '@gamepark/rules-api';
+import { Agent } from '../../material/Agent';
+import { Influence } from '../../material/Influence';
+import { LocationType } from '../../material/LocationType';
+import { PlayerId } from '../../PlayerId';
+import { TeamColor } from '../../TeamColor';
+export declare class InfluenceHelper extends MaterialRulesPart {
+    readonly team: TeamColor;
+    constructor(game: MaterialGame, team: TeamColor);
+    getCost(item: MaterialItem<PlayerId, LocationType, Agent | undefined>, decreaseInfluenceBy?: number): number;
+    getInfluence(influence: Influence): import("@gamepark/rules-api").Material<number, number, number>;
+    get influence(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/helper/InfluenceHelper.js

@@ -0,0 +1,47 @@
+"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.InfluenceHelper = 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 InfluenceHelper = (function (_super) {
+    __extends(InfluenceHelper, _super);
+    function InfluenceHelper(game, team) {
+        var _this = _super.call(this, game) || this;
+        _this.team = team;
+        return _this;
+    }
+    InfluenceHelper.prototype.getCost = function (item, decreaseInfluenceBy) {
+        if (decreaseInfluenceBy === void 0) { decreaseInfluenceBy = 0; }
+        var description = Agents_1.Agents[item.id];
+        return Math.max(0, description.cost - (this.getInfluence(description.influence).length - decreaseInfluenceBy));
+    };
+    InfluenceHelper.prototype.getInfluence = function (influence) {
+        return this.influence.locationId(influence);
+    };
+    Object.defineProperty(InfluenceHelper.prototype, "influence", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.Influence).player(this.team);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return InfluenceHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.InfluenceHelper = InfluenceHelper;

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

@@ -0,0 +1,10 @@
+import { MaterialGame, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerId } from '../../PlayerId';
+export declare class MobilizeHelper extends MaterialRulesPart {
+    readonly player: PlayerId;
+    private playerHelper;
+    constructor(game: MaterialGame, player: PlayerId);
+    mobilize(): MaterialMove[];
+    isPossible(): boolean;
+    get deck(): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
+}

package/dist/rules/helper/MobilizeHelper.js

@@ -0,0 +1,56 @@
+"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.MobilizeHelper = 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 PlayerHelper_1 = require("./PlayerHelper");
+var MobilizeHelper = (function (_super) {
+    __extends(MobilizeHelper, _super);
+    function MobilizeHelper(game, player) {
+        var _this = _super.call(this, game) || this;
+        _this.player = player;
+        _this.playerHelper = new PlayerHelper_1.PlayerHelper(game, player);
+        return _this;
+    }
+    MobilizeHelper.prototype.mobilize = function () {
+        var _this = this;
+        var _a;
+        var agent = this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck().limit(1);
+        if (!agent.length || !((_a = agent.getItem()) === null || _a === void 0 ? void 0 : _a.id))
+            return [];
+        return agent.moveItems(function (item) { return ({
+            type: LocationType_1.LocationType.Influence,
+            id: Agents_1.Agents[item.id].influence,
+            player: _this.playerHelper.team
+        }); });
+    };
+    MobilizeHelper.prototype.isPossible = function () {
+        return this.deck.length > 0;
+    };
+    Object.defineProperty(MobilizeHelper.prototype, "deck", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MobilizeHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.MobilizeHelper = MobilizeHelper;

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

@@ -0,0 +1,19 @@
+import { Material, MaterialGame, MaterialRulesPart } from '@gamepark/rules-api';
+import { GiveInfluenceEffect, ResetInfluenceEffect, WinInfluenceEffect } from '../../material/effect/Effect';
+import { Influence } from '../../material/Influence';
+import { PlayerId } from '../../PlayerId';
+export declare class PlanetHelper extends MaterialRulesPart {
+    readonly player: PlayerId;
+    private playerHelper;
+    constructor(game: MaterialGame, player: PlayerId);
+    getPushablePlanets(effect: GiveInfluenceEffect): Material;
+    getPullablePlanets(effect: WinInfluenceEffect): Material;
+    getResetablePlanets(): Material<number, number, number>;
+    isPossibleToPull(effect: WinInfluenceEffect): boolean;
+    isPossibleToPush(effect: GiveInfluenceEffect): boolean;
+    isAlreadyPlayed(influence: Influence): boolean | undefined;
+    get alreadyPlayedPlanets(): Influence[] | undefined;
+    isPossibleToReset(_effect: ResetInfluenceEffect): boolean;
+    get planets(): Material<number, number, number>;
+    getPlanet(influence: Influence): Material<number, number, number>;
+}

package/dist/rules/helper/PlanetHelper.js

@@ -0,0 +1,104 @@
+"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.PlanetHelper = 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 Memory_1 = require("../Memory");
+var PlayerHelper_1 = require("./PlayerHelper");
+var PlanetHelper = (function (_super) {
+    __extends(PlanetHelper, _super);
+    function PlanetHelper(game, player) {
+        var _this = _super.call(this, game) || this;
+        _this.player = player;
+        _this.playerHelper = new PlayerHelper_1.PlayerHelper(game, player);
+        return _this;
+    }
+    PlanetHelper.prototype.getPushablePlanets = function (effect) {
+        var planets = this.planets;
+        if (effect.except)
+            return planets.filter(function (item) { return item.id !== effect.except; });
+        return planets;
+    };
+    PlanetHelper.prototype.getPullablePlanets = function (effect) {
+        var _this = this;
+        var _a;
+        var planets = this.planets;
+        var filteredPlanets = effect.differentPlanet && ((_a = this.alreadyPlayedPlanets) === null || _a === void 0 ? void 0 : _a.length) ? planets.id(function (id) { return !_this.isAlreadyPlayed(id); }) : planets;
+        if (!filteredPlanets.length)
+            return filteredPlanets;
+        if (effect.fromCenter) {
+            var centeredPlanets = filteredPlanets.filter(function (planet) { return planet.location.x === 0; });
+            if (!centeredPlanets.length)
+                return centeredPlanets;
+            if (effect.influence)
+                return centeredPlanets.id(effect.influence);
+        }
+        else if (effect.opponentSide) {
+            var opponentSidePlanets = filteredPlanets.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 (effect.influence)
+                return opponentSidePlanets.id(effect.influence);
+        }
+        else {
+            if (effect.influence) {
+                return planets.id(effect.influence);
+            }
+        }
+        return planets;
+    };
+    PlanetHelper.prototype.getResetablePlanets = function () {
+        return this.planets.filter(function (planet) { return planet.location.x !== 0; });
+    };
+    PlanetHelper.prototype.isPossibleToPull = function (effect) {
+        return this.getPullablePlanets(effect).length > 0;
+    };
+    PlanetHelper.prototype.isPossibleToPush = function (effect) {
+        return this.getPushablePlanets(effect).length > 0;
+    };
+    PlanetHelper.prototype.isAlreadyPlayed = function (influence) {
+        var _a;
+        return (_a = this.alreadyPlayedPlanets) === null || _a === void 0 ? void 0 : _a.includes(influence);
+    };
+    Object.defineProperty(PlanetHelper.prototype, "alreadyPlayedPlanets", {
+        get: function () {
+            return this.remind(Memory_1.Memory.LastPlanetsMoved);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PlanetHelper.prototype.isPossibleToReset = function (_effect) {
+        return this.getResetablePlanets().length > 0;
+    };
+    Object.defineProperty(PlanetHelper.prototype, "planets", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.InfluenceDisc).location(LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PlanetHelper.prototype.getPlanet = function (influence) {
+        return this.material(MaterialType_1.MaterialType.InfluenceDisc).location(LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace).id(influence);
+    };
+    return PlanetHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.PlanetHelper = PlanetHelper;

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

@@ -0,0 +1,12 @@
+import { MaterialGame, MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerId } from '../../PlayerId';
+import { TeamColor } from '../../TeamColor';
+export declare class PlayerHelper extends MaterialRulesPart {
+    readonly playerId: PlayerId;
+    team: TeamColor;
+    constructor(game: MaterialGame, playerId: PlayerId);
+    get credits(): number;
+    get zenithium(): number;
+    get zenithiumMaterial(): import("@gamepark/rules-api").Material<number, number, number>;
+    get isLeader(): boolean;
+}

package/dist/rules/helper/PlayerHelper.js

@@ -0,0 +1,61 @@
+"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.PlayerHelper = 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 PlayerHelper = (function (_super) {
+    __extends(PlayerHelper, _super);
+    function PlayerHelper(game, playerId) {
+        var _this = _super.call(this, game) || this;
+        _this.playerId = playerId;
+        _this.team = (0, TeamColor_1.getTeamColor)(playerId);
+        return _this;
+    }
+    Object.defineProperty(PlayerHelper.prototype, "credits", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.CreditToken).money(Credit_1.credits).player(this.team).count;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayerHelper.prototype, "zenithium", {
+        get: function () {
+            return this.zenithiumMaterial.getQuantity();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayerHelper.prototype, "zenithiumMaterial", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.ZenithiumToken).player(this.team);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayerHelper.prototype, "isLeader", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.LeaderBadgeToken).player(this.team).length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PlayerHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.PlayerHelper = PlayerHelper;

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

@@ -0,0 +1,4 @@
+import { MaterialMove, MoveItem, PlayerTurnRule } from '@gamepark/rules-api';
+export declare class TechnologyHelper extends PlayerTurnRule {
+    applyTechnology(move: MoveItem): MaterialMove[];
+}