@gamepark/mythologies 0.9.3 → 0.11.0

package/dist/rules/effects/DullahanEffectRule.js

@@ -1,73 +1,48 @@
-"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.DullahanEffectRule = void 0;
-var CustomMoveType_1 = require("../../CustomMoveType");
-var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
-var Pantheon_1 = require("../../material/Pantheon");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var DullahanEffectRule = (function (_super) {
-    __extends(DullahanEffectRule, _super);
-    function DullahanEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.DullahanEffect;
-        return _this;
-    }
-    DullahanEffectRule.prototype.onRuleStart = function () {
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        var targetEntitiesAbleToMove = this.getMovingCards()
-            .filter(function (item) { return pantheon.isAbleToMove(item); })
-            .getIndexes();
-        if (targetEntitiesAbleToMove.length === 0) {
-            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-        }
-        this.memorize(Memory_1.Memory.TargetEntities, targetEntitiesAbleToMove);
-        this.memorize(Memory_1.Memory.EffectCount, targetEntitiesAbleToMove.length);
-        var moves = this.getPlayerMoves();
-        if (moves.length === targetEntitiesAbleToMove.length) {
-            return moves;
-        }
-        return [];
-    };
-    DullahanEffectRule.prototype.getMovingCards = function () {
-        return new Pantheon_1.Pantheon(this.game, this.player).visibleEntities.location(function (l) { return l.y === 1; });
-    };
-    DullahanEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
-        return cardLocation.x === space.x && cardLocation.y === space.y - 1;
-    };
-    DullahanEffectRule.prototype.onCardMoved = function (move) {
-        var moves = [];
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        if (pantheon.visibleEntities.location(function (l) { return l.x === move.location.x && l.y === move.location.y; }).length > 0) {
-            moves.push(pantheon.gainGems(1));
-        }
-        this.memorize(Memory_1.Memory.TargetEntities, function (entities) { return entities.filter(function (index) { return index !== move.itemIndex; }); });
-        var count = this.memorize(Memory_1.Memory.EffectCount, function (count) { return count - 1; });
-        if (count === 0) {
-            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-        }
-        return moves;
-    };
-    DullahanEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.TargetEntities);
-        this.forget(Memory_1.Memory.EffectCount);
-        return [];
-    };
-    return DullahanEffectRule;
-}(MoveEffectRule_1.MoveEffectRule));
-exports.DullahanEffectRule = DullahanEffectRule;
+import { CustomMoveType } from '../../CustomMoveType';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class DullahanEffectRule extends MoveEffectRule {
+    ruleId = RuleId.DullahanEffect;
+    onRuleStart() {
+        const pantheon = new Pantheon(this.game, this.player);
+        const targetEntitiesAbleToMove = this.getMovingCards()
+            .filter((item) => pantheon.isAbleToMove(item))
+            .getIndexes();
+        if (targetEntitiesAbleToMove.length === 0) {
+            return [this.customMove(CustomMoveType.EndEffect)];
+        }
+        this.memorize(Memory.TargetEntities, targetEntitiesAbleToMove);
+        this.memorize(Memory.EffectCount, targetEntitiesAbleToMove.length);
+        const moves = this.getPlayerMoves();
+        if (moves.length === targetEntitiesAbleToMove.length) {
+            return moves;
+        }
+        return [];
+    }
+    getMovingCards() {
+        return new Pantheon(this.game, this.player).visibleEntities.location((l) => l.y === 1);
+    }
+    isLegalDestination(space, cardLocation) {
+        return cardLocation.x === space.x && cardLocation.y === space.y - 1;
+    }
+    onCardMoved(move) {
+        const moves = [];
+        const pantheon = new Pantheon(this.game, this.player);
+        if (pantheon.visibleEntities.location((l) => l.x === move.location.x && l.y === move.location.y).length > 0) {
+            moves.push(pantheon.gainGems(1));
+        }
+        this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex));
+        const count = this.memorize(Memory.EffectCount, (count) => count - 1);
+        if (count === 0) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    onRuleEnd() {
+        this.forget(Memory.TargetEntities);
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

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

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

package/dist/rules/effects/FairyEffectRule.js

@@ -1,55 +1,33 @@
-"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.FairyEffectRule = void 0;
-var CustomMoveType_1 = require("../../CustomMoveType");
-var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var FairyEffectRule = (function (_super) {
-    __extends(FairyEffectRule, _super);
-    function FairyEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.FairyEffect;
-        return _this;
-    }
-    FairyEffectRule.prototype.playEffect = function () {
-        var _a = this.card.location, x = _a.x, y = _a.y;
-        var targets = new Pantheon_1.Pantheon(this.game, this.player).visibleEntities.location(function (l) { return l.y === y && l.x !== x; }).sort(function (item) { return item.location.x; }).getIndexes();
-        this.memorize(Memory_1.Memory.TargetEntities, targets);
-        return _super.prototype.playEffect.call(this);
-    };
-    FairyEffectRule.prototype.getCardsToSacrifice = function () {
-        return this.material(MaterialType_1.MaterialType.EntityCard).index(this.remind(Memory_1.Memory.TargetEntities)[0]);
-    };
-    FairyEffectRule.prototype.onSacrifice = function () {
-        var moves = [new Pantheon_1.Pantheon(this.game, this.player).gainGems(2)];
-        var targets = this.memorize(Memory_1.Memory.TargetEntities, function (targets) { return targets.slice(1); });
-        if (!targets.length) {
-            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-        }
-        return moves;
-    };
-    FairyEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.TargetEntities);
-        return [];
-    };
-    return FairyEffectRule;
-}(SacrificeEffectRule_1.SacrificeEffectRule));
-exports.FairyEffectRule = FairyEffectRule;
+import { CustomMoveType } from '../../CustomMoveType';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class FairyEffectRule extends SacrificeEffectRule {
+    ruleId = RuleId.FairyEffect;
+    playEffect() {
+        const { x, y } = this.card.location;
+        const targets = new Pantheon(this.game, this.player).visibleEntities
+            .location((l) => l.y === y && l.x !== x)
+            .sort((item) => item.location.x)
+            .getIndexes();
+        this.memorize(Memory.TargetEntities, targets);
+        return super.playEffect();
+    }
+    getCardsToSacrifice() {
+        return this.material(MaterialType.EntityCard).index(this.remind(Memory.TargetEntities)[0]);
+    }
+    onSacrifice() {
+        const moves = [new Pantheon(this.game, this.player).gainGems(2)];
+        const targets = this.memorize(Memory.TargetEntities, (targets) => targets.slice(1));
+        if (!targets.length) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    onRuleEnd() {
+        this.forget(Memory.TargetEntities);
+        return [];
+    }
+}

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

@@ -1,8 +1,8 @@
-import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
-import { RuleId } from '../RuleId';
-export declare class FenghuangEffectRule extends PlaceCardEffectRule {
-    ruleId: RuleId;
-    onRuleStart(): never[];
-    getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
-    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
-}
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class FenghuangEffectRule extends PlaceCardEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): never[];
+    getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MaterialMove[];
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/FenghuangEffectRule.js

@@ -1,48 +1,18 @@
-"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.FenghuangEffectRule = void 0;
-var CustomMoveType_1 = require("../../CustomMoveType");
-var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
-var MaterialType_1 = require("../../material/MaterialType");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var FenghuangEffectRule = (function (_super) {
-    __extends(FenghuangEffectRule, _super);
-    function FenghuangEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.FenghuangEffect;
-        return _this;
-    }
-    FenghuangEffectRule.prototype.onRuleStart = function () {
-        var _this = this;
-        this.memorize(Memory_1.Memory.OncePerTurn, function (indexes) {
-            if (indexes === void 0) { indexes = []; }
-            return indexes.concat(_this.getEffect().cardIndex);
-        });
-        return [];
-    };
-    FenghuangEffectRule.prototype.getPlayerMoves = function (cardIndex) {
-        if (cardIndex === void 0) { cardIndex = this.getEffect().cardIndex; }
-        return _super.prototype.getPlayerMoves.call(this, cardIndex).concat(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-    };
-    FenghuangEffectRule.prototype.getCardsToPlace = function () {
-        return this.material(MaterialType_1.MaterialType.EntityCard).index(this.getEffect().cardIndex);
-    };
-    return FenghuangEffectRule;
-}(PlaceCardEffectRule_1.PlaceCardEffectRule));
-exports.FenghuangEffectRule = FenghuangEffectRule;
+import { CustomMoveType } from '../../CustomMoveType';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class FenghuangEffectRule extends PlaceCardEffectRule {
+    ruleId = RuleId.FenghuangEffect;
+    onRuleStart() {
+        this.memorize(Memory.OncePerTurn, (indexes = []) => indexes.concat(this.getEffect().cardIndex));
+        return [];
+    }
+    getPlayerMoves(cardIndex = this.getEffect().cardIndex) {
+        return super.getPlayerMoves(cardIndex).concat(this.customMove(CustomMoveType.EndEffect));
+    }
+    getCardsToPlace() {
+        return this.material(MaterialType.EntityCard).index(this.getEffect().cardIndex);
+    }
+}

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

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

package/dist/rules/effects/FenrirEffectRule.js

@@ -1,139 +1,85 @@
-"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 CustomMoveType_1 = require("../../CustomMoveType");
-var PlayerEffectRule_1 = require("../../material/entity/PlayerEffectRule");
-var SimultaneousEffectRule_1 = require("../../material/entity/SimultaneousEffectRule");
-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.customMove(CustomMoveType_1.CustomMoveType.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; }
-            }
-            if (playersWithChoice.length > 0) {
-                moves.push(this.startSimultaneousRule(RuleId_1.RuleId.FenrirEffect, playersWithChoice));
-            }
-            else {
-                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-            }
-            return moves;
-        }
-        return [];
-    };
-    return FenrirChoiceRule;
-}(PlayerEffectRule_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.EffectCount, player)) {
-                this.memorize(Memory_1.Memory.EffectCount, true, player);
-            }
-            else {
-                return [this.endPlayerTurn(player)];
-            }
-        }
-        return [];
-    };
-    FenrirEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.EffectCount);
-        return [];
-    };
-    return FenrirEffectRule;
-}(SimultaneousEffectRule_1.SimultaneousEffectRule));
-exports.FenrirEffectRule = FenrirEffectRule;
+import { isDeleteItem, isDeleteItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { SimultaneousEffectRule } from '../../material/entity/SimultaneousEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class FenrirChoiceRule extends PlayerEffectRule {
+    ruleId = RuleId.FenrirChoice;
+    getPlayerMoves() {
+        const moves = [this.customMove(CustomMoveType.EndEffect)];
+        const pantheon = new Pantheon(this.game, this.player);
+        if (pantheon.gems && this.getAffectedPlayers().length) {
+            moves.push(pantheon.spendGems(1));
+        }
+        return moves;
+    }
+    getAffectedPlayers() {
+        return this.game.players.filter((player) => {
+            const pantheon = new Pantheon(this.game, player);
+            return player !== this.player && (pantheon.gems > 0 || pantheon.favor > 0);
+        });
+    }
+    beforeItemMove(move) {
+        if (isDeleteItemType(MaterialType.GemToken)(move) && this.material(MaterialType.GemToken).getItem(move.itemIndex).location.player === this.player) {
+            const moves = [];
+            const players = this.getAffectedPlayers();
+            const playersWithChoice = [];
+            for (const player of players) {
+                const pantheon = new Pantheon(this.game, player);
+                const { gems, favor } = pantheon;
+                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);
+                }
+            }
+            if (playersWithChoice.length > 0) {
+                moves.push(this.startSimultaneousRule(RuleId.FenrirEffect, playersWithChoice));
+            }
+            else {
+                moves.push(this.customMove(CustomMoveType.EndEffect));
+            }
+            return moves;
+        }
+        return [];
+    }
+}
+export class FenrirEffectRule extends SimultaneousEffectRule {
+    getActivePlayerLegalMoves(player) {
+        const moves = [];
+        const pantheon = new Pantheon(this.game, player);
+        if (pantheon.favor) {
+            moves.push(pantheon.loseFavor());
+        }
+        if (pantheon.gems) {
+            moves.push(pantheon.spendGems(1));
+        }
+        return moves;
+    }
+    beforeItemMove(move) {
+        if (isDeleteItem(move)) {
+            const player = this.material(move.itemType).getItem(move.itemIndex).location.player;
+            if (!this.remind(Memory.EffectCount, player)) {
+                this.memorize(Memory.EffectCount, true, player);
+            }
+            else {
+                return [this.endPlayerTurn(player)];
+            }
+        }
+        return [];
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

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

@@ -1,16 +1,16 @@
-import { CustomMove, MaterialMove } from '@gamepark/rules-api';
-import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
-import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
-import { RuleId } from '../RuleId';
-export declare class GarudaEffectRule extends PlayerEffectRule {
-    ruleId: RuleId;
-    getPlayerMoves(): CustomMove<number>[];
-    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
-}
-export declare class GarudaSacrificeRule extends SacrificeEffectRule {
-    ruleId: RuleId;
-    onRuleStart(): MaterialMove<number, number, number, number>[];
-    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(): CustomMove<number>[];
-    onRuleEnd(): never[];
-}
+import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class GarudaEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): CustomMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+}
+export declare class GarudaSacrificeRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): MaterialMove[];
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(): CustomMove[];
+    onRuleEnd(): never[];
+}