@gamepark/mythologies 0.1.0

package/dist/rules/effects/BennuEffectRule.d.ts

@@ -0,0 +1,6 @@
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class BennuEffectRule extends PlaceCardEffectRule {
+    ruleId: RuleId;
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/BennuEffectRule.js

@@ -0,0 +1,35 @@
+"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.BennuEffectRule = void 0;
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var RuleId_1 = require("../RuleId");
+var BennuEffectRule = (function (_super) {
+    __extends(BennuEffectRule, _super);
+    function BennuEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.BennuEffect;
+        return _this;
+    }
+    BennuEffectRule.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerDiscard);
+    };
+    return BennuEffectRule;
+}(PlaceCardEffectRule_1.PlaceCardEffectRule));
+exports.BennuEffectRule = BennuEffectRule;

package/dist/rules/effects/CentaurEffectRule.d.ts

@@ -0,0 +1,15 @@
+import { Location, Material, XYCoordinates } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { SimultaneousSacrificeEffectRule } from '../../material/entity/SimultaneousSacrificeEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class CentaurEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    getMovingCards(effectCardIndex?: number): Material;
+    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
+    endEffect(): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+    get playersHavingToSacrifice(): number[];
+}
+export declare class CentaurEffectSacrificeRule extends SimultaneousSacrificeEffectRule {
+    getCardsToSacrifice(player: PlayerColor): Material;
+}

package/dist/rules/effects/CentaurEffectRule.js

@@ -0,0 +1,77 @@
+"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.CentaurEffectSacrificeRule = exports.CentaurEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Entity_1 = require("../../material/Entity");
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var SimultaneousSacrificeEffectRule_1 = require("../../material/entity/SimultaneousSacrificeEffectRule");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var CentaurEffectRule = (function (_super) {
+    __extends(CentaurEffectRule, _super);
+    function CentaurEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.CentaurEffect;
+        return _this;
+    }
+    CentaurEffectRule.prototype.getMovingCards = function (effectCardIndex) {
+        if (effectCardIndex === void 0) { effectCardIndex = this.getEffect().cardIndex; }
+        return this.material(MaterialType_1.MaterialType.EntityCard).index(effectCardIndex);
+    };
+    CentaurEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
+        return (0, rules_api_1.areAdjacentSquares)(space, cardLocation);
+    };
+    CentaurEffectRule.prototype.endEffect = function () {
+        var players = this.playersHavingToSacrifice;
+        if (players.length) {
+            var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+            return pantheon.gainBonus().concat(this.startSimultaneousRule(RuleId_1.RuleId.CentaurEffectSacrifice, players));
+        }
+        else {
+            return _super.prototype.endEffect.call(this);
+        }
+    };
+    Object.defineProperty(CentaurEffectRule.prototype, "playersHavingToSacrifice", {
+        get: function () {
+            var _this = this;
+            return this.game.players.filter(function (player) { return new Pantheon_1.Pantheon(_this.game, player).grid[_this.card.location.y].filter(Entity_1.isCreature).length > (player === _this.player ? 1 : 0); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CentaurEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.CentaurEffectRule = CentaurEffectRule;
+var CentaurEffectSacrificeRule = (function (_super) {
+    __extends(CentaurEffectSacrificeRule, _super);
+    function CentaurEffectSacrificeRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CentaurEffectSacrificeRule.prototype.getCardsToSacrifice = function (player) {
+        var cardIndex = this.remind(Memory_1.Memory.OngoingEffect).cardIndex;
+        var centaurLine = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location.y;
+        return _super.prototype.getCardsToSacrifice.call(this, player)
+            .index(function (index) { return index !== cardIndex; })
+            .id(function (id) { return (0, Entity_1.isCreature)(id.front); })
+            .location(function (l) { return l.y === centaurLine; });
+    };
+    return CentaurEffectSacrificeRule;
+}(SimultaneousSacrificeEffectRule_1.SimultaneousSacrificeEffectRule));
+exports.CentaurEffectSacrificeRule = CentaurEffectSacrificeRule;

package/dist/rules/effects/ChimeraEffectRule.d.ts

@@ -0,0 +1,8 @@
+import { XYCoordinates } from '@gamepark/rules-api';
+import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class ChimeraEffectRule extends InvokeEffectRule {
+    ruleId: RuleId;
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableDestinations(): XYCoordinates[];
+}

package/dist/rules/effects/ChimeraEffectRule.js

@@ -0,0 +1,51 @@
+"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.ChimeraEffectRule = void 0;
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var ChimeraEffectRule = (function (_super) {
+    __extends(ChimeraEffectRule, _super);
+    function ChimeraEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.ChimeraEffect;
+        return _this;
+    }
+    ChimeraEffectRule.prototype.getCardsToPlace = function () {
+        var mythologies = this.material(MaterialType_1.MaterialType.MythologyBoard)
+            .getItems()
+            .map(function (item) { return item.id.mythology; });
+        var creaturesInDecks = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck);
+        var creaturesIndexes = mythologies.map(function (mythology) {
+            return creaturesInDecks
+                .locationId(mythology)
+                .maxBy(function (item) { return item.location.x; })
+                .getIndex();
+        });
+        return this.material(MaterialType_1.MaterialType.EntityCard).index(creaturesIndexes);
+    };
+    ChimeraEffectRule.prototype.getAvailableDestinations = function () {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.card.location.player);
+        var space = this.card.location;
+        return pantheon.isLegalSpaceToInvoke(space) ? [space] : [];
+    };
+    return ChimeraEffectRule;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.ChimeraEffectRule = ChimeraEffectRule;

package/dist/rules/effects/CobraEffectRule.d.ts

@@ -0,0 +1,12 @@
+import { MoveItem } from '@gamepark/rules-api';
+import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class CobraEffectRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(move: MoveItem): (MoveItem<number, number, number> | import("@gamepark/rules-api").StartRule<RuleId.CobraInvokeEffect>)[];
+}
+export declare class CobraInvokeEffect extends InvokeEffectRule {
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/CobraEffectRule.js

@@ -0,0 +1,55 @@
+"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.CobraInvokeEffect = exports.CobraEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var RuleId_1 = require("../RuleId");
+var CobraEffectRule = (function (_super) {
+    __extends(CobraEffectRule, _super);
+    function CobraEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.CobraEffect;
+        return _this;
+    }
+    CobraEffectRule.prototype.getCardsToSacrifice = function () {
+        var _a = this.card.location, x = _a.x, y = _a.y;
+        return _super.prototype.getCardsToSacrifice.call(this).location(function (l) { return l.x === x && l.y !== y; });
+    };
+    CobraEffectRule.prototype.onSacrifice = function (move) {
+        var cards = this.material(MaterialType_1.MaterialType.EntityCard);
+        var mythology = (0, Entity_1.entityMythology)(cards.getItem(move.itemIndex).id.front);
+        var creaturesDeck = cards.location(LocationType_1.LocationType.CreaturesDeck).locationId(mythology);
+        return [creaturesDeck.maxBy(function (item) { return item.location.x; }).rotateItem(true), this.startRule(RuleId_1.RuleId.CobraInvokeEffect)];
+    };
+    return CobraEffectRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.CobraEffectRule = CobraEffectRule;
+var CobraInvokeEffect = (function (_super) {
+    __extends(CobraInvokeEffect, _super);
+    function CobraInvokeEffect() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CobraInvokeEffect.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).rotation(true);
+    };
+    return CobraInvokeEffect;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.CobraInvokeEffect = CobraInvokeEffect;

package/dist/rules/effects/CyclopsEffectRule.d.ts

@@ -0,0 +1,8 @@
+import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { RuleId } from '../RuleId';
+export declare class CyclopsEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
+}

package/dist/rules/effects/CyclopsEffectRule.js

@@ -0,0 +1,87 @@
+"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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclopsEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var CustomMoveType_1 = require("../../CustomMoveType");
+var Effect_1 = require("../../material/entity/Effect");
+var LocationType_1 = require("../../material/LocationType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var CyclopsEffectRule = (function (_super) {
+    __extends(CyclopsEffectRule, _super);
+    function CyclopsEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.CyclopsEffect;
+        return _this;
+    }
+    CyclopsEffectRule.prototype.getPlayerMoves = function () {
+        var e_1, _a;
+        var moves = [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
+        var canPay = new Pantheon_1.Pantheon(this.game, this.player).gems > 0;
+        if (canPay) {
+            var event = this.getEffect().triggerEvent;
+            try {
+                for (var _b = __values((0, rules_api_1.getNeighbors)(this.player, this.game.players)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var neighbor = _c.value;
+                    var pantheon = new Pantheon_1.Pantheon(this.game, neighbor);
+                    var bonus = event.type === Effect_1.TriggerEventType.LineBonusGain ? pantheon.getBonusGem(event.y) : pantheon.getBonusFavor(event.x);
+                    if (bonus.length) {
+                        moves.push(this.customMove(CustomMoveType_1.CustomMoveType.ChoosePlayer, neighbor));
+                    }
+                }
+            }
+            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 moves;
+    };
+    CyclopsEffectRule.prototype.onCustomMove = function (move) {
+        if (move.type === CustomMoveType_1.CustomMoveType.ChoosePlayer) {
+            var moves = [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
+            var neighbor = move.data;
+            var event = this.getEffect().triggerEvent;
+            if (event.type === Effect_1.TriggerEventType.LineBonusGain) {
+                moves.push(new Pantheon_1.Pantheon(this.game, neighbor).getBonusGem(event.y).moveItem({ type: LocationType_1.LocationType.PlayerGems, player: this.player }));
+            }
+            else {
+                moves.push(new Pantheon_1.Pantheon(this.game, neighbor).getBonusFavor(event.x).moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: this.player }));
+            }
+            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+            return moves;
+        }
+        return [];
+    };
+    return CyclopsEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.CyclopsEffectRule = CyclopsEffectRule;

package/dist/rules/effects/DraugrEffectRule.d.ts

@@ -0,0 +1,11 @@
+import { ItemMove, Material } from '@gamepark/rules-api';
+import { SimultaneousSacrificeEffectRule } from '../../material/entity/SimultaneousSacrificeEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class DraugrEffectRule extends SimultaneousSacrificeEffectRule {
+    ruleId: RuleId;
+    getAffectedPlayers(): PlayerColor[];
+    getActivePlayerLegalMoves(player: PlayerColor): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+    getCardsToSacrifice(player: PlayerColor): Material;
+    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<number>[];
+}

package/dist/rules/effects/DraugrEffectRule.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.DraugrEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Entity_1 = require("../../material/Entity");
+var SimultaneousSacrificeEffectRule_1 = require("../../material/entity/SimultaneousSacrificeEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var RuleId_1 = require("../RuleId");
+var DraugrEffectRule = (function (_super) {
+    __extends(DraugrEffectRule, _super);
+    function DraugrEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.DraugrEffect;
+        return _this;
+    }
+    DraugrEffectRule.prototype.getAffectedPlayers = function () {
+        var _this = this;
+        return _super.prototype.getAffectedPlayers.call(this).filter(function (player) { return _this.isOpponent(player); });
+    };
+    DraugrEffectRule.prototype.getActivePlayerLegalMoves = function (player) {
+        var moves = _super.prototype.getActivePlayerLegalMoves.call(this, player);
+        var gems = this.material(MaterialType_1.MaterialType.GemToken).location(LocationType_1.LocationType.PlayerGems).player(player);
+        var owner = this.card.location.player;
+        if (gems.getQuantity() >= 2 || (gems.getQuantity() === 1 && moves.length === 0)) {
+            moves.push(gems.moveItem({ type: LocationType_1.LocationType.PlayerGems, player: owner }, 2));
+        }
+        return moves;
+    };
+    DraugrEffectRule.prototype.getCardsToSacrifice = function (player) {
+        return _super.prototype.getCardsToSacrifice.call(this, player).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
+    };
+    DraugrEffectRule.prototype.beforeItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.GemToken)(move)) {
+            return [this.endPlayerTurn(this.material(MaterialType_1.MaterialType.GemToken).getItem(move.itemIndex).location.player)];
+        }
+        return [];
+    };
+    return DraugrEffectRule;
+}(SimultaneousSacrificeEffectRule_1.SimultaneousSacrificeEffectRule));
+exports.DraugrEffectRule = DraugrEffectRule;

package/dist/rules/effects/FenrirEffectRule.d.ts

@@ -0,0 +1,15 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule, SimultaneousEffectRule } from '../../material/entity/Effect';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class FenrirChoiceRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    getAffectedPlayers(): number[];
+    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+}
+export declare class FenrirEffectRule extends SimultaneousEffectRule {
+    getActivePlayerLegalMoves(player: PlayerColor): MaterialMove<number, number, number, number>[];
+    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<number>[];
+    onRuleEnd(): never[];
+}

package/dist/rules/effects/FenrirEffectRule.js

@@ -0,0 +1,132 @@
+"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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FenrirEffectRule = exports.FenrirChoiceRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/entity/Effect");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var FenrirChoiceRule = (function (_super) {
+    __extends(FenrirChoiceRule, _super);
+    function FenrirChoiceRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.FenrirChoice;
+        return _this;
+    }
+    FenrirChoiceRule.prototype.getPlayerMoves = function () {
+        var moves = this.endEffect();
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        if (pantheon.gems && this.getAffectedPlayers().length) {
+            moves.push(pantheon.spendGems(1));
+        }
+        return moves;
+    };
+    FenrirChoiceRule.prototype.getAffectedPlayers = function () {
+        var _this = this;
+        return this.game.players.filter(function (player) {
+            var pantheon = new Pantheon_1.Pantheon(_this.game, player);
+            return player !== _this.player && (pantheon.gems > 0 || pantheon.favor > 0);
+        });
+    };
+    FenrirChoiceRule.prototype.beforeItemMove = function (move) {
+        var e_1, _a;
+        if ((0, rules_api_1.isDeleteItemType)(MaterialType_1.MaterialType.GemToken)(move) && this.material(MaterialType_1.MaterialType.GemToken).getItem(move.itemIndex).location.player === this.player) {
+            var moves = [];
+            var players = this.getAffectedPlayers();
+            var playersWithChoice = [];
+            try {
+                for (var players_1 = __values(players), players_1_1 = players_1.next(); !players_1_1.done; players_1_1 = players_1.next()) {
+                    var player = players_1_1.value;
+                    var pantheon = new Pantheon_1.Pantheon(this.game, player);
+                    var gems = pantheon.gems, favor = pantheon.favor;
+                    if (!favor) {
+                        moves.push(pantheon.spendGems(2));
+                    }
+                    else if (!gems) {
+                        moves.push(pantheon.loseFavor(2));
+                    }
+                    else if (gems === 1 && favor === 1) {
+                        moves.push(pantheon.spendGems(1), pantheon.loseFavor(1));
+                    }
+                    else {
+                        playersWithChoice.push(player);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (players_1_1 && !players_1_1.done && (_a = players_1.return)) _a.call(players_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            moves.push(this.startSimultaneousRule(RuleId_1.RuleId.FenrirEffect, playersWithChoice));
+            return moves;
+        }
+        return [];
+    };
+    return FenrirChoiceRule;
+}(Effect_1.PlayerEffectRule));
+exports.FenrirChoiceRule = FenrirChoiceRule;
+var FenrirEffectRule = (function (_super) {
+    __extends(FenrirEffectRule, _super);
+    function FenrirEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    FenrirEffectRule.prototype.getActivePlayerLegalMoves = function (player) {
+        var moves = [];
+        var pantheon = new Pantheon_1.Pantheon(this.game, player);
+        if (pantheon.favor) {
+            moves.push(pantheon.loseFavor());
+        }
+        if (pantheon.gems) {
+            moves.push(pantheon.spendGems(1));
+        }
+        return moves;
+    };
+    FenrirEffectRule.prototype.beforeItemMove = function (move) {
+        if ((0, rules_api_1.isDeleteItem)(move)) {
+            var player = this.material(move.itemType).getItem(move.itemIndex).location.player;
+            if (!this.remind(Memory_1.Memory.FenrirPaid1, player)) {
+                this.memorize(Memory_1.Memory.FenrirPaid1, true, player);
+            }
+            else {
+                return [this.endPlayerTurn(player)];
+            }
+        }
+        return [];
+    };
+    FenrirEffectRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.FenrirPaid1);
+        return [];
+    };
+    return FenrirEffectRule;
+}(Effect_1.SimultaneousEffectRule));
+exports.FenrirEffectRule = FenrirEffectRule;

package/dist/rules/effects/GarudaEffectRule.d.ts

@@ -0,0 +1,9 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class GarudaEffectRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(): MaterialMove<number, number, number, number>[];
+}