@gamepark/zenith 0.0.1

package/dist/rules/MulliganRule.js

@@ -0,0 +1,138 @@
+"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.MulliganRule = 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 Memory_1 = require("./Memory");
+var RuleId_1 = require("./RuleId");
+var MulliganRule = (function (_super) {
+    __extends(MulliganRule, _super);
+    function MulliganRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MulliganRule.prototype.getActivePlayerLegalMoves = function (player) {
+        return __spreadArray(__spreadArray([], __read(this.getHand(player).moveItems({
+            type: LocationType_1.LocationType.AgentDiscard
+        })), false), [
+            this.customMove(CustomMoveType_1.CustomMoveType.Pass, player)
+        ], false);
+    };
+    MulliganRule.prototype.onCustomMove = function (move) {
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.Pass)(move))
+            return [];
+        var player = move.data;
+        var mulliganCount = this.getMulliganCount(player);
+        var moves = [];
+        if (mulliganCount) {
+            var deck = this.deck;
+            moves.push(deck.dealAtOnce({
+                type: LocationType_1.LocationType.PlayerHand,
+                player: player
+            }, mulliganCount));
+        }
+        moves.push(this.endPlayerTurn(player));
+        return moves;
+    };
+    MulliganRule.prototype.getMulliganCount = function (player) {
+        var _a;
+        return (_a = this.remind(Memory_1.Memory.Mulligan, player)) !== null && _a !== void 0 ? _a : 0;
+    };
+    Object.defineProperty(MulliganRule.prototype, "deck", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MulliganRule.prototype.beforeItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move) || move.location.type !== LocationType_1.LocationType.AgentDiscard)
+            return [];
+        var item = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
+        var player = item.location.player;
+        var mulliganCount = this.getMulliganCount(player);
+        this.memorize(Memory_1.Memory.Mulligan, mulliganCount + 1, player);
+        return [];
+    };
+    MulliganRule.prototype.getHand = function (playerId) {
+        return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.PlayerHand).player(playerId);
+    };
+    MulliganRule.prototype.getMovesAfterPlayersDone = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                this.forget(Memory_1.Memory.Mulligan, player);
+            }
+        }
+        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 [this.startPlayerTurn(RuleId_1.RuleId.PlayCard, this.turnOrder[0])];
+    };
+    Object.defineProperty(MulliganRule.prototype, "turnOrder", {
+        get: function () {
+            return this.remind(Memory_1.Memory.TurnOrder);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MulliganRule;
+}(rules_api_1.SimultaneousRule));
+exports.MulliganRule = MulliganRule;

package/dist/rules/PlayCardRule.d.ts

@@ -0,0 +1,15 @@
+import { ItemMove, Material, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { CreditHelper } from './helper/CreditHelper';
+import { InfluenceHelper } from './helper/InfluenceHelper';
+import { PlayerHelper } from './helper/PlayerHelper';
+export declare class PlayCardRule extends PlayerTurnRule {
+    onRuleStart(): never[];
+    getPlayerMoves(): MaterialMove[];
+    placeInInfluence(cards: Material): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    discardAgents(cards: Material): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    get creditHelper(): CreditHelper;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    get influenceHelper(): InfluenceHelper;
+    get playerHelper(): PlayerHelper;
+    get hand(): Material<number, number, number>;
+}

package/dist/rules/PlayCardRule.js

@@ -0,0 +1,147 @@
+"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.PlayCardRule = 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 TeamColor_1 = require("../TeamColor");
+var CreditHelper_1 = require("./helper/CreditHelper");
+var EffectHelper_1 = require("./helper/EffectHelper");
+var InfluenceHelper_1 = require("./helper/InfluenceHelper");
+var PlayerHelper_1 = require("./helper/PlayerHelper");
+var Memory_1 = require("./Memory");
+var RuleId_1 = require("./RuleId");
+var PlayCardRule = (function (_super) {
+    __extends(PlayCardRule, _super);
+    function PlayCardRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PlayCardRule.prototype.onRuleStart = function () {
+        this.forget(Memory_1.Memory.DiscardFaction);
+        this.forget(Memory_1.Memory.LastPlanetsMoved);
+        return [];
+    };
+    PlayCardRule.prototype.getPlayerMoves = function () {
+        var moves = [];
+        var hand = this.hand;
+        moves.push.apply(moves, __spreadArray([], __read(this.discardAgents(hand)), false));
+        moves.push.apply(moves, __spreadArray([], __read(this.placeInInfluence(hand)), false));
+        return moves;
+    };
+    PlayCardRule.prototype.placeInInfluence = function (cards) {
+        var _this = this;
+        var influenceHelper = this.influenceHelper;
+        var playerHelper = this.playerHelper;
+        return cards
+            .filter(function (item) { return influenceHelper.getCost(item) <= playerHelper.credits; })
+            .moveItems(function (item) { return ({
+            type: LocationType_1.LocationType.Influence,
+            id: Agents_1.Agents[item.id].influence,
+            player: (0, TeamColor_1.getTeamColor)(_this.player)
+        }); });
+    };
+    PlayCardRule.prototype.discardAgents = function (cards) {
+        return cards.moveItems({
+            type: LocationType_1.LocationType.AgentDiscard
+        });
+    };
+    Object.defineProperty(PlayCardRule.prototype, "creditHelper", {
+        get: function () {
+            return new CreditHelper_1.CreditHelper(this.game, this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PlayCardRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.AgentCard)(move))
+            return [];
+        if (move.location.type === LocationType_1.LocationType.AgentDiscard) {
+            var item = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
+            var agent = Agents_1.Agents[item.id];
+            this.memorize(Memory_1.Memory.DiscardFaction, agent.faction);
+            return [this.startRule(RuleId_1.RuleId.DiscardAction)];
+        }
+        var moves = [];
+        if (move.location.type === LocationType_1.LocationType.Influence) {
+            var influenceHelper = this.influenceHelper;
+            var item = this.material(MaterialType_1.MaterialType.AgentCard).getItem(move.itemIndex);
+            this.memorize(Memory_1.Memory.CardPlayed, item.id);
+            var cost = influenceHelper.getCost(item, 1);
+            if (cost > 0) {
+                moves.push.apply(moves, __spreadArray([], __read(this.creditHelper.spendCredit(cost)), false));
+            }
+            var helper = new EffectHelper_1.EffectHelper(this.game, this.player);
+            var effectMoves = helper.applyCard(item);
+            if (effectMoves.some(function (move) { return (0, rules_api_1.isStartRule)(move) || (0, rules_api_1.isStartPlayerTurn)(move); })) {
+                moves.push.apply(moves, __spreadArray([], __read(effectMoves), false));
+                return moves;
+            }
+            moves.push(this.startRule(RuleId_1.RuleId.Refill));
+        }
+        return moves;
+    };
+    Object.defineProperty(PlayCardRule.prototype, "influenceHelper", {
+        get: function () {
+            return new InfluenceHelper_1.InfluenceHelper(this.game, (0, TeamColor_1.getTeamColor)(this.player));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayCardRule.prototype, "playerHelper", {
+        get: function () {
+            return new PlayerHelper_1.PlayerHelper(this.game, this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayCardRule.prototype, "hand", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.PlayerHand).player(this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PlayCardRule;
+}(rules_api_1.PlayerTurnRule));
+exports.PlayCardRule = PlayCardRule;

package/dist/rules/RefillRule.d.ts

@@ -0,0 +1,17 @@
+import { ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { Influence } from '../material/Influence';
+import { PlayerId } from '../PlayerId';
+export declare class RefillRule extends PlayerTurnRule {
+    onRuleStart(): MaterialMove[];
+    getNewInfluenceDisc(influence: Influence): import("@gamepark/rules-api").Material<number, number, number>;
+    get endRuleMoves(): MaterialMove[];
+    get turnOrder(): PlayerId[];
+    get nextPlayer(): PlayerId;
+    get handSize(): 4 | 5 | 6;
+    refillHand(maxCount: number): MaterialMove[];
+    get discard(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    get hand(): import("@gamepark/rules-api").Material<number, number, number>;
+    get deck(): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
+    get leaderBadge(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/RefillRule.js

@@ -0,0 +1,211 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefillRule = 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 PlayerHelper_1 = require("./helper/PlayerHelper");
+var Memory_1 = require("./Memory");
+var RuleId_1 = require("./RuleId");
+var RefillRule = (function (_super) {
+    __extends(RefillRule, _super);
+    function RefillRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RefillRule.prototype.onRuleStart = function () {
+        var e_1, _a;
+        var _this = this;
+        this.memorize(Memory_1.Memory.AlreadyPlayedPlayers, function (p) {
+            if (p === void 0) { p = []; }
+            return p.concat(_this.player);
+        });
+        var moves = [];
+        try {
+            for (var influences_1 = __values(Influence_1.influences), influences_1_1 = influences_1.next(); !influences_1_1.done; influences_1_1 = influences_1.next()) {
+                var influence = influences_1_1.value;
+                var planet = this.material(MaterialType_1.MaterialType.InfluenceDisc).location(LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace).locationId(influence);
+                if (planet.length)
+                    continue;
+                moves.push(this.getNewInfluenceDisc(influence).moveItem({
+                    type: LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace,
+                    id: influence,
+                    x: 0
+                }));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (influences_1_1 && !influences_1_1.done && (_a = influences_1.return)) _a.call(influences_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var maxSize = this.handSize;
+        moves.push.apply(moves, __spreadArray([], __read(this.refillHand(maxSize)), false));
+        if (moves.some(function (move) { return (0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDeck; })) {
+            return moves;
+        }
+        moves.push.apply(moves, __spreadArray([], __read(this.endRuleMoves), false));
+        return moves;
+    };
+    RefillRule.prototype.getNewInfluenceDisc = function (influence) {
+        return this.material(MaterialType_1.MaterialType.InfluenceDisc)
+            .location(LocationType_1.LocationType.InfluenceDiscStock)
+            .locationId(influence)
+            .maxBy(function (item) { return item.location.x; });
+    };
+    Object.defineProperty(RefillRule.prototype, "endRuleMoves", {
+        get: function () {
+            var isTurnEnded = this.remind(Memory_1.Memory.AlreadyPlayedPlayers).length === this.game.players.length;
+            if (isTurnEnded) {
+                this.forget(Memory_1.Memory.AlreadyPlayedPlayers);
+                return [this.startPlayerTurn(RuleId_1.RuleId.PlayCard, this.turnOrder[0])];
+            }
+            else {
+                return [this.startPlayerTurn(RuleId_1.RuleId.PlayCard, this.nextPlayer)];
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RefillRule.prototype, "turnOrder", {
+        get: function () {
+            return this.remind(Memory_1.Memory.TurnOrder);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RefillRule.prototype, "nextPlayer", {
+        get: function () {
+            var players = this.turnOrder;
+            return players[(players.indexOf(this.player) + 1) % players.length];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RefillRule.prototype, "handSize", {
+        get: function () {
+            var leaderBadge = this.leaderBadge;
+            if (!leaderBadge.length) {
+                return 4;
+            }
+            else {
+                var item = leaderBadge.getItem();
+                if (!item.location.rotation) {
+                    return 5;
+                }
+                else {
+                    return 6;
+                }
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RefillRule.prototype.refillHand = function (maxCount) {
+        var deck = this.deck;
+        var quantity = Math.max(0, maxCount - this.hand.length);
+        if (!quantity)
+            return [];
+        var moves = deck.deal({
+            type: LocationType_1.LocationType.PlayerHand,
+            player: this.player
+        }, quantity);
+        var remaining = quantity - moves.length;
+        if (!remaining)
+            return moves;
+        moves.push(this.discard.moveItemsAtOnce({ type: LocationType_1.LocationType.AgentDeck }));
+        return moves;
+    };
+    Object.defineProperty(RefillRule.prototype, "discard", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDiscard);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RefillRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isShuffleItemType)(MaterialType_1.MaterialType.AgentCard)(move)) {
+            return __spreadArray(__spreadArray([], __read(this.refillHand(this.handSize)), false), __read(this.endRuleMoves), false);
+        }
+        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.AgentCard)(move) && move.location.type === LocationType_1.LocationType.AgentDeck) {
+            return [this.deck.shuffle()];
+        }
+        return [];
+    };
+    Object.defineProperty(RefillRule.prototype, "hand", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.PlayerHand).player(this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RefillRule.prototype, "deck", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RefillRule.prototype, "leaderBadge", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.LeaderBadgeToken).player(new PlayerHelper_1.PlayerHelper(this.game, this.player).team);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RefillRule;
+}(rules_api_1.PlayerTurnRule));
+exports.RefillRule = RefillRule;

package/dist/rules/RuleId.d.ts

@@ -0,0 +1,27 @@
+export declare enum RuleId {
+    Muligan = 1,
+    PlayCard = 2,
+    DiscardAction = 3,
+    Transfer = 4,
+    GiveCredit = 5,
+    WinCredit = 6,
+    SpendCredit = 7,
+    Conditional = 8,
+    WinZenithium = 9,
+    GiveZenithium = 10,
+    Exile = 11,
+    WinInfluence = 12,
+    GiveInfluence = 13,
+    ResetInfluence = 14,
+    DevelopTechnology = 15,
+    GiveLeaderBadge = 16,
+    TakeLeaderBadge = 17,
+    Discard = 18,
+    Mobilize = 19,
+    Choice = 20,
+    TakeBonus = 21,
+    Refill = 22,
+    StealCredit = 23,
+    SpendZenithium = 24,
+    TakeTechnologyBonusToken = 25
+}

package/dist/rules/RuleId.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleId = void 0;
+var RuleId;
+(function (RuleId) {
+    RuleId[RuleId["Muligan"] = 1] = "Muligan";
+    RuleId[RuleId["PlayCard"] = 2] = "PlayCard";
+    RuleId[RuleId["DiscardAction"] = 3] = "DiscardAction";
+    RuleId[RuleId["Transfer"] = 4] = "Transfer";
+    RuleId[RuleId["GiveCredit"] = 5] = "GiveCredit";
+    RuleId[RuleId["WinCredit"] = 6] = "WinCredit";
+    RuleId[RuleId["SpendCredit"] = 7] = "SpendCredit";
+    RuleId[RuleId["Conditional"] = 8] = "Conditional";
+    RuleId[RuleId["WinZenithium"] = 9] = "WinZenithium";
+    RuleId[RuleId["GiveZenithium"] = 10] = "GiveZenithium";
+    RuleId[RuleId["Exile"] = 11] = "Exile";
+    RuleId[RuleId["WinInfluence"] = 12] = "WinInfluence";
+    RuleId[RuleId["GiveInfluence"] = 13] = "GiveInfluence";
+    RuleId[RuleId["ResetInfluence"] = 14] = "ResetInfluence";
+    RuleId[RuleId["DevelopTechnology"] = 15] = "DevelopTechnology";
+    RuleId[RuleId["GiveLeaderBadge"] = 16] = "GiveLeaderBadge";
+    RuleId[RuleId["TakeLeaderBadge"] = 17] = "TakeLeaderBadge";
+    RuleId[RuleId["Discard"] = 18] = "Discard";
+    RuleId[RuleId["Mobilize"] = 19] = "Mobilize";
+    RuleId[RuleId["Choice"] = 20] = "Choice";
+    RuleId[RuleId["TakeBonus"] = 21] = "TakeBonus";
+    RuleId[RuleId["Refill"] = 22] = "Refill";
+    RuleId[RuleId["StealCredit"] = 23] = "StealCredit";
+    RuleId[RuleId["SpendZenithium"] = 24] = "SpendZenithium";
+    RuleId[RuleId["TakeTechnologyBonusToken"] = 25] = "TakeTechnologyBonusToken";
+})(RuleId || (exports.RuleId = RuleId = {}));

package/dist/rules/discard-action/DiplomacyActions.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from '../../material/effect/Effect';
+import { Faction } from '../../material/Faction';
+export declare const getDiplomacyActions: (_players: number) => Record<Faction, Effect[]>;

package/dist/rules/discard-action/DiplomacyActions.js

@@ -0,0 +1,39 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiplomacyActions = void 0;
+var EffectType_1 = require("../../material/effect/EffectType");
+var Faction_1 = require("../../material/Faction");
+var getDiplomacyActions = function (_players) {
+    return TwoPlayerDiplomacyActions;
+};
+exports.getDiplomacyActions = getDiplomacyActions;
+var TwoPlayerDiplomacyActions = (_a = {},
+    _a[Faction_1.Faction.Robot] = [
+        {
+            type: EffectType_1.EffectType.TakeLeaderBadge
+        },
+        {
+            type: EffectType_1.EffectType.WinZenithium,
+            quantity: 1
+        }
+    ],
+    _a[Faction_1.Faction.Human] = [
+        {
+            type: EffectType_1.EffectType.TakeLeaderBadge
+        },
+        {
+            type: EffectType_1.EffectType.WinCredit,
+            quantity: 3
+        }
+    ],
+    _a[Faction_1.Faction.Animod] = [
+        {
+            type: EffectType_1.EffectType.TakeLeaderBadge
+        },
+        {
+            type: EffectType_1.EffectType.Mobilize,
+            quantity: 2
+        }
+    ],
+    _a);

package/dist/rules/discard-action/DiplomacyBoardRule.d.ts

@@ -0,0 +1,9 @@
+import { CustomMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { Faction } from '../../material/Faction';
+import { RuleId } from '../RuleId';
+export declare class DiplomacyBoardRule extends PlayerTurnRule {
+    getPlayerMoves(): CustomMove[];
+    get faction(): Faction;
+    applyDiplomacy(): import("@gamepark/rules-api").StartRule<RuleId>[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").StartRule<RuleId>[];
+}