@gamepark/zenith 0.0.1

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

@@ -0,0 +1,68 @@
+"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.DiplomacyBoardRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var MaterialType_1 = require("../../material/MaterialType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var EffectHelper_1 = require("../helper/EffectHelper");
+var Memory_1 = require("../Memory");
+var RuleId_1 = require("../RuleId");
+var DiplomacyActions_1 = require("./DiplomacyActions");
+var DiplomacyBoardRule = (function (_super) {
+    __extends(DiplomacyBoardRule, _super);
+    function DiplomacyBoardRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DiplomacyBoardRule.prototype.getPlayerMoves = function () {
+        return [this.customMove(CustomMoveType_1.CustomMoveType.Diplomacy)];
+    };
+    Object.defineProperty(DiplomacyBoardRule.prototype, "faction", {
+        get: function () {
+            return this.remind(Memory_1.Memory.DiscardFaction);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DiplomacyBoardRule.prototype.applyDiplomacy = function () {
+        var _this = this;
+        this.memorize(Memory_1.Memory.Effects, JSON.parse(JSON.stringify((0, DiplomacyActions_1.getDiplomacyActions)(this.game.players.length)[this.faction].map(function (effect) { return (__assign(__assign({}, effect), { effectSource: { type: MaterialType_1.MaterialType.DiplomacyBoard, key: _this.faction } })); }))));
+        return new EffectHelper_1.EffectHelper(this.game, this.player).applyFirstEffect();
+    };
+    DiplomacyBoardRule.prototype.onCustomMove = function (move) {
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.Diplomacy)(move))
+            return [];
+        var effectMoves = this.applyDiplomacy();
+        if (effectMoves.some(function (move) { return (0, rules_api_1.isStartRule)(move) || (0, rules_api_1.isStartPlayerTurn)(move); })) {
+            return effectMoves;
+        }
+        return [this.startRule(RuleId_1.RuleId.Refill)];
+    };
+    return DiplomacyBoardRule;
+}(rules_api_1.PlayerTurnRule));
+exports.DiplomacyBoardRule = DiplomacyBoardRule;

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

@@ -0,0 +1,3 @@
+import { Effect } from '../../material/effect/Effect';
+export declare const getTechnologyAction: (id: string) => Effect[][];
+export declare const TechnologyLineBonuses: Effect[];

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

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TechnologyLineBonuses = exports.getTechnologyAction = void 0;
+var Effect_1 = require("../../material/effect/Effect");
+var EffectType_1 = require("../../material/effect/EffectType");
+var Faction_1 = require("../../material/Faction");
+var getTechnologyAction = function (id) {
+    switch (id) {
+        case 'S':
+            return TechnologySActions;
+        case 'U':
+            return TechnologyUActions;
+        case 'N':
+        default:
+            return TechnologyNActions;
+    }
+};
+exports.getTechnologyAction = getTechnologyAction;
+var TechnologySActions = [
+    [
+        {
+            type: EffectType_1.EffectType.WinCredit,
+            quantity: 2
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            pattern: [1, 1]
+        },
+        {
+            type: EffectType_1.EffectType.TakeTechnologyBonusToken,
+            faction: Faction_1.Faction.Animod,
+            x: 2
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.Transfer,
+            quantity: 3
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.Conditional,
+            mandatory: true,
+            condition: {
+                type: Effect_1.ConditionType.DoEffect,
+                effect: {
+                    type: EffectType_1.EffectType.Mobilize
+                }
+            },
+            effect: {
+                type: EffectType_1.EffectType.WinInfluence,
+                quantity: 1
+            }
+        },
+        {
+            type: EffectType_1.EffectType.Conditional,
+            mandatory: true,
+            condition: {
+                type: Effect_1.ConditionType.DoEffect,
+                effect: {
+                    type: EffectType_1.EffectType.Mobilize
+                }
+            },
+            effect: {
+                type: EffectType_1.EffectType.WinInfluence,
+                quantity: 1
+            }
+        },
+        {
+            type: EffectType_1.EffectType.Conditional,
+            mandatory: true,
+            condition: {
+                type: Effect_1.ConditionType.DoEffect,
+                effect: {
+                    type: EffectType_1.EffectType.Mobilize
+                }
+            },
+            effect: {
+                type: EffectType_1.EffectType.WinInfluence,
+                quantity: 1
+            }
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            quantity: 2
+        }
+    ]
+];
+var TechnologyUActions = [
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            quantity: 1
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.Mobilize,
+            quantity: 2
+        },
+        {
+            type: EffectType_1.EffectType.TakeTechnologyBonusToken,
+            faction: Faction_1.Faction.Human,
+            x: 2
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.StealCredit,
+            quantity: 3
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            pattern: [1, 1, 1]
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            quantity: 2
+        }
+    ]
+];
+var TechnologyNActions = [
+    [
+        {
+            type: EffectType_1.EffectType.Transfer,
+            quantity: 1
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.TakeLeaderBadge
+        },
+        {
+            type: EffectType_1.EffectType.TakeTechnologyBonusToken,
+            faction: Faction_1.Faction.Robot,
+            x: 2
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            resetDifferentPlanet: true,
+            quantity: 2
+        },
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            differentPlanet: true,
+            quantity: 1
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinCredit,
+            quantity: 20
+        }
+    ],
+    [
+        {
+            type: EffectType_1.EffectType.WinInfluence,
+            resetDifferentPlanet: true,
+            quantity: 2
+        }
+    ]
+];
+exports.TechnologyLineBonuses = [
+    {
+        type: EffectType_1.EffectType.WinInfluence,
+        quantity: 1
+    },
+    {
+        type: EffectType_1.EffectType.WinInfluence,
+        quantity: 2
+    },
+    {
+        type: EffectType_1.EffectType.WinInfluence,
+        quantity: 3
+    }
+];

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

@@ -0,0 +1,8 @@
+import { ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { Faction } from '../../material/Faction';
+export declare class TechnologyBoardRule extends PlayerTurnRule {
+    getPlayerMoves(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+    get marker(): import("@gamepark/rules-api").Material<number, number, number>;
+    get faction(): Faction;
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __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.TechnologyBoardRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var EffectHelper_1 = require("../helper/EffectHelper");
+var PlayerHelper_1 = require("../helper/PlayerHelper");
+var TechnologyHelper_1 = require("../helper/TechnologyHelper");
+var Memory_1 = require("../Memory");
+var RuleId_1 = require("../RuleId");
+var TechnologyBoardRule = (function (_super) {
+    __extends(TechnologyBoardRule, _super);
+    function TechnologyBoardRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TechnologyBoardRule.prototype.getPlayerMoves = function () {
+        var marker = this.marker;
+        var item = marker.getItem();
+        if (item.location.x >= 5)
+            return [];
+        var zenithiumCost = item.location.x + 1;
+        if (new PlayerHelper_1.PlayerHelper(this.game, this.player).zenithium < zenithiumCost)
+            return [];
+        return this.marker.moveItems(function (item) { return (__assign(__assign({}, item.location), { x: item.location.x + 1 })); });
+    };
+    TechnologyBoardRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.TechMarker)(move))
+            return [];
+        var moves = new TechnologyHelper_1.TechnologyHelper(this.game).applyTechnology(move);
+        moves.push(new PlayerHelper_1.PlayerHelper(this.game, this.player).zenithiumMaterial.deleteItem(move.location.x));
+        var effectMoves = new EffectHelper_1.EffectHelper(this.game, this.player).applyFirstEffect();
+        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(TechnologyBoardRule.prototype, "marker", {
+        get: function () {
+            var playerHelper = new PlayerHelper_1.PlayerHelper(this.game, this.player);
+            var board = this.material(MaterialType_1.MaterialType.TechnologyBoard).location(LocationType_1.LocationType.TechnologyBoardPlace).locationId(this.faction);
+            return this.material(MaterialType_1.MaterialType.TechMarker).location(LocationType_1.LocationType.TechnologyBoardTokenSpace).player(playerHelper.team).parent(board.getIndex());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TechnologyBoardRule.prototype, "faction", {
+        get: function () {
+            return this.remind(Memory_1.Memory.DiscardFaction);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TechnologyBoardRule;
+}(rules_api_1.PlayerTurnRule));
+exports.TechnologyBoardRule = TechnologyBoardRule;

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

@@ -0,0 +1,12 @@
+import { CustomMove } from '@gamepark/rules-api';
+import { ChoiceEffect } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare enum Choice {
+    LEFT = 1,
+    RIGHT = 2
+}
+export declare class ChoiceRule extends EffectRule<ChoiceEffect> {
+    getPlayerMoves(): CustomMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").StartRule<import("../RuleId").RuleId>[];
+    choice(choice: Choice): void;
+}

package/dist/rules/effect/ChoiceRule.js

@@ -0,0 +1,91 @@
+"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.ChoiceRule = exports.Choice = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var MaterialType_1 = require("../../material/MaterialType");
+var CustomMoveType_1 = require("../CustomMoveType");
+var Memory_1 = require("../Memory");
+var index_1 = require("./index");
+var Choice;
+(function (Choice) {
+    Choice[Choice["LEFT"] = 1] = "LEFT";
+    Choice[Choice["RIGHT"] = 2] = "RIGHT";
+})(Choice || (exports.Choice = Choice = {}));
+var ChoiceRule = (function (_super) {
+    __extends(ChoiceRule, _super);
+    function ChoiceRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ChoiceRule.prototype.getPlayerMoves = function () {
+        return [this.customMove(CustomMoveType_1.CustomMoveType.Choice, Choice.LEFT), this.customMove(CustomMoveType_1.CustomMoveType.Choice, Choice.RIGHT)];
+    };
+    ChoiceRule.prototype.onCustomMove = function (move) {
+        if (!(0, rules_api_1.isCustomMoveType)(MaterialType_1.MaterialType.InfluenceDisc)(move))
+            return [];
+        this.choice(move.data);
+        return this.applyFirstEffect();
+    };
+    ChoiceRule.prototype.choice = function (choice) {
+        this.memorize(Memory_1.Memory.Effects, function (effects) {
+            var firstEffect = effects[0];
+            var left = firstEffect.left, right = firstEffect.right;
+            if (choice === Choice.LEFT) {
+                return __spreadArray([__assign(__assign({}, left), { effectSource: firstEffect.effectSource })], __read(effects.slice(1)), false);
+            }
+            return __spreadArray([__assign(__assign({}, right), { effectSource: firstEffect.effectSource })], __read(effects.slice(1)), false);
+        });
+    };
+    return ChoiceRule;
+}(index_1.EffectRule));
+exports.ChoiceRule = ChoiceRule;

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

@@ -0,0 +1,17 @@
+import { CustomMove, ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { Condition, ConditionalEffect, DoEffectCondition, HaveCreditsCondition, LeaderCondition } from '../../material/effect/Effect';
+import { EffectRule } from './index';
+export declare class ConditionalRule extends EffectRule<ConditionalEffect> {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+    onEffectPlayed(move: ItemMove | CustomMove): boolean | undefined;
+    get isAutomaticEffect(): boolean;
+    isDoCondition(condition: Condition): condition is DoEffectCondition;
+    isLeaderCondition(condition: Condition): condition is LeaderCondition;
+    isHaveCreditCondition(condition: Condition): condition is HaveCreditsCondition;
+    isPossible(): boolean;
+    addEffectAndRemoveCondition(extraData?: Record<string, unknown>): void;
+    onRuleEnd(): never[];
+}