@gamepark/zenith 0.0.1

package/dist/rules/effect/TakeLeaderBadgeRule.js

@@ -0,0 +1,102 @@
+"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.TakeLeaderBadgeRule = 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 TakeLeaderBadgeRule = (function (_super) {
+    __extends(TakeLeaderBadgeRule, _super);
+    function TakeLeaderBadgeRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TakeLeaderBadgeRule.prototype.onRuleStart = function () {
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        this.memorize(Memory_1.Memory.CurrentEffect, JSON.parse(JSON.stringify(this.effect)));
+        var leaderBadge = this.leader;
+        var item = leaderBadge.getItem();
+        var team = this.playerHelper.team;
+        if (item.location.player === team) {
+            if (!item.location.rotation) {
+                moves.push(leaderBadge.rotateItem(this.newBadgeRotation));
+            }
+        }
+        else {
+            moves.push.apply(moves, __spreadArray([], __read(leaderBadge.moveItems({
+                type: LocationType_1.LocationType.TeamLeaderBadge,
+                rotation: this.newBadgeRotation,
+                player: team
+            })), false));
+        }
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    Object.defineProperty(TakeLeaderBadgeRule.prototype, "newBadgeRotation", {
+        get: function () {
+            var leaderBadge = this.leader;
+            var item = leaderBadge.getItem();
+            var team = this.playerHelper.team;
+            if (item.location.player === team && !item.location.rotation)
+                return true;
+            return this.effect.gold;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TakeLeaderBadgeRule.prototype, "leader", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.LeaderBadgeToken);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TakeLeaderBadgeRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.CurrentEffect);
+        return [];
+    };
+    return TakeLeaderBadgeRule;
+}(index_1.EffectRule));
+exports.TakeLeaderBadgeRule = TakeLeaderBadgeRule;

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

@@ -0,0 +1,11 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { TakeTechnologyBonusToken } from '../../material/effect/Effect';
+import { TechnologyBonusResult } from '../helper/BonusHelper';
+import { EffectRule } from './EffectRule';
+export declare class TakeTechnologyBonusTokenRule extends EffectRule<TakeTechnologyBonusToken> {
+    onRuleStart(): MaterialMove[];
+    get bonusEffect(): TechnologyBonusResult | undefined;
+    get board(): import("@gamepark/rules-api").Material<number, number, number>;
+    isPossible(): boolean;
+    onRuleEnd(): never[];
+}

package/dist/rules/effect/TakeTechnologyBonusTokenRule.js

@@ -0,0 +1,122 @@
+"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.TakeTechnologyBonusTokenRule = void 0;
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var BonusHelper_1 = require("../helper/BonusHelper");
+var Memory_1 = require("../Memory");
+var EffectRule_1 = require("./EffectRule");
+var TakeTechnologyBonusTokenRule = (function (_super) {
+    __extends(TakeTechnologyBonusTokenRule, _super);
+    function TakeTechnologyBonusTokenRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TakeTechnologyBonusTokenRule.prototype.onRuleStart = function () {
+        var _this = this;
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        var bonusEffect = this.bonusEffect;
+        this.memorize(Memory_1.Memory.CurrentEffect, JSON.parse(JSON.stringify(this.effect)));
+        this.removeFirstEffect();
+        if (bonusEffect) {
+            this.memorize(Memory_1.Memory.WonBonus, bonusEffect.bonusId);
+            this.memorize(Memory_1.Memory.Effects, function (effects) {
+                if (effects === void 0) { effects = []; }
+                effects.unshift(__assign(__assign({}, bonusEffect.effect), { effectSource: {
+                        type: MaterialType_1.MaterialType.TechnologyBoard,
+                        value: _this.board.getItem().location.id
+                    } }));
+                return effects;
+            });
+            moves.push.apply(moves, __spreadArray([], __read(bonusEffect.moves), false));
+        }
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    Object.defineProperty(TakeTechnologyBonusTokenRule.prototype, "bonusEffect", {
+        get: function () {
+            var effect = this.effect;
+            var board = this.board;
+            var token = this.material(MaterialType_1.MaterialType.TechMarker)
+                .location(LocationType_1.LocationType.TechnologyBoardTokenSpace)
+                .parent(board.getIndex())
+                .player(this.playerHelper.team);
+            var item = token.getItem();
+            if (item.location.x !== effect.x)
+                return undefined;
+            return new BonusHelper_1.BonusHelper(this.game).getTechnologyBonus(token);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TakeTechnologyBonusTokenRule.prototype, "board", {
+        get: function () {
+            var effect = this.effect;
+            return this.material(MaterialType_1.MaterialType.TechnologyBoard).locationId(effect.faction);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TakeTechnologyBonusTokenRule.prototype.isPossible = function () {
+        return this.bonusEffect !== undefined;
+    };
+    TakeTechnologyBonusTokenRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.WonBonus);
+        this.forget(Memory_1.Memory.CurrentEffect);
+        return [];
+    };
+    return TakeTechnologyBonusTokenRule;
+}(EffectRule_1.EffectRule));
+exports.TakeTechnologyBonusTokenRule = TakeTechnologyBonusTokenRule;

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

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

package/dist/rules/effect/TransferRule.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.TransferRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Agents_1 = require("../../material/Agents");
+var Influence_1 = require("../../material/Influence");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var index_1 = require("./index");
+var TransferRule = (function (_super) {
+    __extends(TransferRule, _super);
+    function TransferRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TransferRule.prototype.onRuleStart = function () {
+        var _a;
+        var moves = _super.prototype.onRuleStart.call(this);
+        if (moves.length > 0)
+            return moves;
+        if (this.effect.influence && ((_a = this.effect.quantity) !== null && _a !== void 0 ? _a : 1) === 1)
+            return this.transferOneCard();
+        return moves;
+    };
+    TransferRule.prototype.getPlayerMoves = function () {
+        return this.transferOneCard();
+    };
+    TransferRule.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 || !this.isPossible();
+        }
+        return true;
+    };
+    TransferRule.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.isPossible()) {
+            this.removeFirstEffect();
+            return this.afterEffectPlayed();
+        }
+        return [];
+    };
+    TransferRule.prototype.isPossible = function () {
+        var _a;
+        return this.influenceCards.length >= ((_a = this.effect.quantity) !== null && _a !== void 0 ? _a : 1);
+    };
+    TransferRule.prototype.transferOneCard = function () {
+        var _this = this;
+        var allInfluences = Influence_1.influences;
+        var allCards = this.influenceCards;
+        return allInfluences
+            .filter(function (influence) { return (_this.effect.influence ? influence === _this.effect.influence : true); })
+            .flatMap(function (influence) {
+            return allCards
+                .locationId(influence)
+                .maxBy(function (item) { return item.location.x; })
+                .moveItems({
+                type: LocationType_1.LocationType.Influence,
+                id: influence,
+                player: _this.playerHelper.team
+            });
+        });
+    };
+    Object.defineProperty(TransferRule.prototype, "influenceCards", {
+        get: function () {
+            var _this = this;
+            var cards = this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.Influence).player(this.opponentTeam);
+            if (this.effect.influence)
+                return cards.filter(function (item) { return Agents_1.Agents[item.id].influence === _this.effect.influence; });
+            return cards;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TransferRule.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 {};
+    };
+    return TransferRule;
+}(index_1.EffectRule));
+exports.TransferRule = TransferRule;

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

@@ -0,0 +1,13 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { WinCreditEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class WinCreditRule extends EffectRule<WinCreditEffect> {
+    onRuleStart(): MaterialMove[];
+    get wonCredit(): number;
+    isPossible(): boolean;
+    get distinctInfluence(): number;
+    get opponentDistinctInfluence(): number;
+    get level1Technology(): number;
+    setExtraData(_extraData: Record<string, unknown>): void;
+    onRuleEnd(): never[];
+}

package/dist/rules/effect/WinCreditRule.js

@@ -0,0 +1,142 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WinCreditRule = void 0;
+var uniq_1 = __importDefault(require("lodash/uniq"));
+var Agents_1 = require("../../material/Agents");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var WinCreditRule = (function (_super) {
+    __extends(WinCreditRule, _super);
+    function WinCreditRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WinCreditRule.prototype.onRuleStart = function () {
+        var moves = [];
+        var money = this.creditMoney;
+        var credits = this.wonCredit;
+        this.memorize(Memory_1.Memory.Credit, credits);
+        this.memorize(Memory_1.Memory.CurrentEffect, JSON.parse(JSON.stringify(this.effect)));
+        moves.push(this.customMove(CustomMoveType_1.CustomMoveType.WinCreditLog, credits));
+        moves.push.apply(moves, __spreadArray([], __read(money.addMoney(credits, { type: LocationType_1.LocationType.TeamCredit, player: this.effect.opponent ? this.opponentTeam : this.playerHelper.team })), false));
+        this.removeFirstEffect();
+        moves.push.apply(moves, __spreadArray([], __read(this.afterEffectPlayed()), false));
+        return moves;
+    };
+    Object.defineProperty(WinCreditRule.prototype, "wonCredit", {
+        get: function () {
+            if (this.effect.quantity)
+                return this.effect.quantity;
+            if (this.effect.perLevel1Technology)
+                return this.effect.perLevel1Technology[this.level1Technology - 1];
+            if (this.effect.factorPerDifferentInfluence)
+                return this.distinctInfluence * this.effect.factorPerDifferentInfluence;
+            if (this.effect.factorPerDifferentOpponentInfluence)
+                return this.opponentDistinctInfluence * this.effect.factorPerDifferentOpponentInfluence;
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WinCreditRule.prototype.isPossible = function () {
+        if (this.effect.perLevel1Technology)
+            return this.level1Technology > 0;
+        if (this.effect.factorPerDifferentInfluence)
+            return this.distinctInfluence > 0;
+        if (this.effect.factorPerDifferentOpponentInfluence)
+            return this.opponentDistinctInfluence > 0;
+        return true;
+    };
+    Object.defineProperty(WinCreditRule.prototype, "distinctInfluence", {
+        get: function () {
+            var items = this.material(MaterialType_1.MaterialType.AgentCard)
+                .location(LocationType_1.LocationType.Influence)
+                .player(this.playerHelper.team)
+                .getItems()
+                .map(function (a) { return Agents_1.Agents[a.id].influence; });
+            return (0, uniq_1.default)(items).length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WinCreditRule.prototype, "opponentDistinctInfluence", {
+        get: function () {
+            var items = this.material(MaterialType_1.MaterialType.AgentCard)
+                .location(LocationType_1.LocationType.Influence)
+                .player(this.opponentTeam)
+                .getItems()
+                .map(function (a) { return Agents_1.Agents[a.id].influence; });
+            return (0, uniq_1.default)(items).length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WinCreditRule.prototype, "level1Technology", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.TechMarker)
+                .player(this.playerHelper.team)
+                .location(function (l) { return l.type === LocationType_1.LocationType.TechnologyBoardTokenSpace && l.x === 1; }).length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WinCreditRule.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);
+        }
+    };
+    WinCreditRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.Credit);
+        this.forget(Memory_1.Memory.CurrentEffect);
+        return [];
+    };
+    return WinCreditRule;
+}(index_1.EffectRule));
+exports.WinCreditRule = WinCreditRule;

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

@@ -0,0 +1,23 @@
+import { ItemMove, Material, MaterialItem, MaterialMove } from '@gamepark/rules-api';
+import { WinInfluenceEffect } from '../../material/effect/Effect';
+import { Influence } from '../../material/Influence';
+import { PatternType } from '../Memory';
+import { EffectRule } from './index';
+export declare class WinInfluenceRule extends EffectRule<WinInfluenceEffect> {
+    onRuleStart(): MaterialMove[];
+    get planets(): Material<number, number, number>;
+    private patternPlanet;
+    computePossiblePatterns(): PatternType[][];
+    private influencePlanet;
+    private opponentSidePlanets;
+    private fromCenterPlanets;
+    getPositionAfterPull(item: MaterialItem, effect: WinInfluenceEffect): number[];
+    private getPositionForQuantity;
+    getPlayerMoves(): MaterialMove[];
+    beforeItemMove(move: ItemMove): MaterialMove[];
+    isAlreadyPlayed(influence: Influence): boolean | undefined;
+    isPossible(): boolean;
+    get lastPlanetsMoved(): Influence[] | undefined;
+    setExtraData(_extraData: Record<string, unknown>): void;
+    onRuleEnd(): never[];
+}