@gamepark/mythologies 0.10.0 → 0.12.0

package/dist/material/entity/SimultaneousEffectRule.js

@@ -1,149 +1,64 @@
-"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.SimultaneousEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var Memory_1 = require("../../Memory");
-var ResolveEffectsRule_1 = require("../../rules/effects/ResolveEffectsRule");
-var MaterialType_1 = require("../MaterialType");
-var SimultaneousEffectRule = (function (_super) {
-    __extends(SimultaneousEffectRule, _super);
-    function SimultaneousEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    SimultaneousEffectRule.prototype.canPlayEffect = function (_cardIndex) {
-        return true;
-    };
-    SimultaneousEffectRule.prototype.playEffect = function () {
-        var e_1, _a;
-        var moves = [];
-        var playersToActivate = [];
-        try {
-            for (var _b = __values(this.getAffectedPlayers()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                var legalMoves = this.getActivePlayerLegalMoves(player);
-                if (legalMoves.length === 1) {
-                    moves.push(legalMoves[0]);
-                }
-                else if (legalMoves.length > 1) {
-                    playersToActivate.push(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; }
-        }
-        moves.push(this.startSimultaneousRule(this.ruleId, playersToActivate));
-        return moves;
-    };
-    SimultaneousEffectRule.prototype.onRuleStart = function () {
-        var e_2, _a;
-        var moves = [];
-        if (this.game.rule.players.length === 0) {
-            moves.push.apply(moves, __spreadArray([], __read(this.getMovesAfterPlayersDone()), false));
-        }
-        try {
-            for (var _b = __values(this.game.rule.players), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                var legalMoves = this.getActivePlayerLegalMoves(player);
-                if (legalMoves.length === 1) {
-                    moves.push(legalMoves[0]);
-                }
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return moves;
-    };
-    SimultaneousEffectRule.prototype.getAffectedPlayers = function () {
-        return this.game.players;
-    };
-    SimultaneousEffectRule.prototype.isOpponent = function (player) {
-        return player !== this.card.location.player;
-    };
-    Object.defineProperty(SimultaneousEffectRule.prototype, "card", {
-        get: function () {
-            var index = this.getEffect().cardIndex;
-            return this.material(MaterialType_1.MaterialType.EntityCard).getItem(index);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    SimultaneousEffectRule.prototype.getEffect = function () {
-        return this.remind(Memory_1.Memory.OngoingEffect);
-    };
-    SimultaneousEffectRule.prototype.getMovesAfterPlayersDone = function () {
-        return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-    };
-    SimultaneousEffectRule.prototype.onCustomMove = function (move) {
-        if (move.type === CustomMoveType_1.CustomMoveType.EndEffect) {
-            return this.onEndEffect();
-        }
-        return [];
-    };
-    SimultaneousEffectRule.prototype.onEndEffect = function () {
-        return new ResolveEffectsRule_1.ResolveEffectsRule(this.game).onEndEffect();
-    };
-    return SimultaneousEffectRule;
-}(rules_api_1.SimultaneousRule));
-exports.SimultaneousEffectRule = SimultaneousEffectRule;
+import { SimultaneousRule } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { Memory } from '../../Memory';
+import { ResolveEffectsRule } from '../../rules/effects/ResolveEffectsRule';
+import { MaterialType } from '../MaterialType';
+export class SimultaneousEffectRule extends SimultaneousRule {
+    canPlayEffect(_cardIndex) {
+        return true;
+    }
+    ruleId;
+    playEffect() {
+        const moves = [];
+        const playersToActivate = [];
+        for (const player of this.getAffectedPlayers()) {
+            const legalMoves = this.getActivePlayerLegalMoves(player);
+            if (legalMoves.length === 1) {
+                moves.push(legalMoves[0]);
+            }
+            else if (legalMoves.length > 1) {
+                playersToActivate.push(player);
+            }
+        }
+        moves.push(this.startSimultaneousRule(this.ruleId, playersToActivate));
+        return moves;
+    }
+    onRuleStart() {
+        const moves = [];
+        if (this.game.rule.players.length === 0) {
+            moves.push(...this.getMovesAfterPlayersDone());
+        }
+        for (const player of this.game.rule.players) {
+            const legalMoves = this.getActivePlayerLegalMoves(player);
+            if (legalMoves.length === 1) {
+                moves.push(legalMoves[0]);
+            }
+        }
+        return moves;
+    }
+    getAffectedPlayers() {
+        return this.game.players;
+    }
+    isOpponent(player) {
+        return player !== this.card.location.player;
+    }
+    get card() {
+        const index = this.getEffect().cardIndex;
+        return this.material(MaterialType.EntityCard).getItem(index);
+    }
+    getEffect() {
+        return this.remind(Memory.OngoingEffect);
+    }
+    getMovesAfterPlayersDone() {
+        return [this.customMove(CustomMoveType.EndEffect)];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.EndEffect) {
+            return this.onEndEffect();
+        }
+        return [];
+    }
+    onEndEffect() {
+        return new ResolveEffectsRule(this.game).onEndEffect();
+    }
+}

package/dist/material/entity/SimultaneousMoveEffectRule.d.ts

@@ -1,17 +1,17 @@
-import { ItemMove, Location, Material, MaterialItem, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
-import { PlayerColor } from '../../PlayerColor';
-import { SimultaneousEffectRule } from './SimultaneousEffectRule';
-export declare abstract class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
-    getActivePlayerLegalMoves(player: PlayerColor): MoveItem<number, number, number>[];
-    getSacrificeToPreventMove(player: PlayerColor): MoveItem<number, number, number>[];
-    getMovementMoves(player: PlayerColor): MoveItem<number, number, number>[];
-    private getCardsAbleToMove;
-    getMovingCards(player: PlayerColor): Material;
-    getAvailableDestinations(player: PlayerColor, card: MaterialItem): XYCoordinates[];
-    isLegalDestination(_space: XYCoordinates, _cardLocation: Location): boolean;
-    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
-    onCardMoved(move: MoveItem): MaterialMove[];
-    onCardSacrificed(move: MoveItem): MaterialMove[];
-    getMovesAfterPlayersDone(): MaterialMove[];
-    updatePlayersGrids(): MoveItem[];
-}
+import { ItemMove, Location, Material, MaterialItem, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
+import { PlayerColor } from '../../PlayerColor';
+import { SimultaneousEffectRule } from './SimultaneousEffectRule';
+export declare abstract class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
+    getActivePlayerLegalMoves(player: PlayerColor): MoveItem<number, number, number>[];
+    getSacrificeToPreventMove(player: PlayerColor): MoveItem<number, number, number>[];
+    getMovementMoves(player: PlayerColor): MoveItem<number, number, number>[];
+    private getCardsAbleToMove;
+    getMovingCards(player: PlayerColor): Material;
+    getAvailableDestinations(player: PlayerColor, card: MaterialItem): XYCoordinates[];
+    isLegalDestination(_space: XYCoordinates, _cardLocation: Location): boolean;
+    beforeItemMove(move: ItemMove): MaterialMove[];
+    onCardMoved(move: MoveItem): MaterialMove[];
+    onCardSacrificed(move: MoveItem): MaterialMove[];
+    getMovesAfterPlayersDone(): MaterialMove[];
+    updatePlayersGrids(): void;
+}

package/dist/material/entity/SimultaneousMoveEffectRule.js

@@ -1,141 +1,64 @@
-"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.SimultaneousMoveEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var TriggerEffectsRule_1 = require("../../rules/effects/TriggerEffectsRule");
-var LocationType_1 = require("../LocationType");
-var MaterialType_1 = require("../MaterialType");
-var Pantheon_1 = require("../Pantheon");
-var SimultaneousEffectRule_1 = require("./SimultaneousEffectRule");
-var SimultaneousMoveEffectRule = (function (_super) {
-    __extends(SimultaneousMoveEffectRule, _super);
-    function SimultaneousMoveEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    SimultaneousMoveEffectRule.prototype.getActivePlayerLegalMoves = function (player) {
-        return this.getMovementMoves(player).concat(this.getSacrificeToPreventMove(player));
-    };
-    SimultaneousMoveEffectRule.prototype.getSacrificeToPreventMove = function (player) {
-        return new Pantheon_1.Pantheon(this.game, player).sacrificeToPreventMove();
-    };
-    SimultaneousMoveEffectRule.prototype.getMovementMoves = function (player) {
-        var _this = this;
-        var cards = this.getCardsAbleToMove(player);
-        return cards.getIndexes().flatMap(function (cardIndex) {
-            var card = cards.index(cardIndex);
-            return _this.getAvailableDestinations(player, card.getItem()).map(function (_a) {
-                var x = _a.x, y = _a.y;
-                return card.moveItem({ type: LocationType_1.LocationType.Pantheon, player: player, x: x, y: y });
-            });
-        });
-    };
-    SimultaneousMoveEffectRule.prototype.getCardsAbleToMove = function (player) {
-        var pantheon = new Pantheon_1.Pantheon(this.game, player);
-        return this.getMovingCards(player).filter(function (item) { return pantheon.isAbleToMove(item); });
-    };
-    SimultaneousMoveEffectRule.prototype.getMovingCards = function (player) {
-        return new Pantheon_1.Pantheon(this.game, player).visibleEntities;
-    };
-    SimultaneousMoveEffectRule.prototype.getAvailableDestinations = function (player, card) {
-        var _this = this;
-        return new Pantheon_1.Pantheon(this.game, player).legalSpaces.filter(function (space) { return (space.y !== card.location.y || space.x !== card.location.x) && _this.isLegalDestination(space, card.location); });
-    };
-    SimultaneousMoveEffectRule.prototype.isLegalDestination = function (_space, _cardLocation) {
-        return true;
-    };
-    SimultaneousMoveEffectRule.prototype.beforeItemMove = function (move) {
-        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move)) {
-            if (move.location.type === LocationType_1.LocationType.Pantheon) {
-                return this.onCardMoved(move);
-            }
-            else if (move.location.type === LocationType_1.LocationType.PlayerDiscard) {
-                return this.onCardSacrificed(move);
-            }
-        }
-        return [];
-    };
-    SimultaneousMoveEffectRule.prototype.onCardMoved = function (move) {
-        return [this.endPlayerTurn(move.location.player)];
-    };
-    SimultaneousMoveEffectRule.prototype.onCardSacrificed = function (move) {
-        return [this.endPlayerTurn(move.location.player)];
-    };
-    SimultaneousMoveEffectRule.prototype.getMovesAfterPlayersDone = function () {
-        return __spreadArray(__spreadArray([], __read(this.updatePlayersGrids()), false), __read(_super.prototype.getMovesAfterPlayersDone.call(this)), false);
-    };
-    SimultaneousMoveEffectRule.prototype.updatePlayersGrids = function () {
-        var e_1, _a, _b;
-        var moves = [];
-        var events = [];
-        try {
-            for (var _c = __values(this.game.players), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var player = _d.value;
-                var pantheon = new Pantheon_1.Pantheon(this.game, player);
-                events.push.apply(events, __spreadArray([], __read(pantheon.updateGrid()), false));
-                moves.push.apply(moves, __spreadArray([], __read(pantheon.gainBonus()), false));
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        (_b = new TriggerEffectsRule_1.TriggerEffectsRule(this.game)).triggerEffects.apply(_b, __spreadArray([], __read(events), false));
-        return moves;
-    };
-    return SimultaneousMoveEffectRule;
-}(SimultaneousEffectRule_1.SimultaneousEffectRule));
-exports.SimultaneousMoveEffectRule = SimultaneousMoveEffectRule;
+import { isMoveItemType } from '@gamepark/rules-api';
+import { TriggerEffectsRule } from '../../rules/effects/TriggerEffectsRule';
+import { LocationType } from '../LocationType';
+import { MaterialType } from '../MaterialType';
+import { Pantheon } from '../Pantheon';
+import { SimultaneousEffectRule } from './SimultaneousEffectRule';
+export class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
+    getActivePlayerLegalMoves(player) {
+        return this.getMovementMoves(player).concat(this.getSacrificeToPreventMove(player));
+    }
+    getSacrificeToPreventMove(player) {
+        return new Pantheon(this.game, player).sacrificeToPreventMove();
+    }
+    getMovementMoves(player) {
+        const cards = this.getCardsAbleToMove(player);
+        return cards.getIndexes().flatMap((cardIndex) => {
+            const card = cards.index(cardIndex);
+            return this.getAvailableDestinations(player, card.getItem()).map(({ x, y }) => card.moveItem({ type: LocationType.Pantheon, player, x, y }));
+        });
+    }
+    getCardsAbleToMove(player) {
+        const pantheon = new Pantheon(this.game, player);
+        return this.getMovingCards(player).filter((item) => pantheon.isAbleToMove(item));
+    }
+    getMovingCards(player) {
+        return new Pantheon(this.game, player).visibleEntities;
+    }
+    getAvailableDestinations(player, card) {
+        return new Pantheon(this.game, player).legalSpaces.filter((space) => (space.y !== card.location.y || space.x !== card.location.x) && this.isLegalDestination(space, card.location));
+    }
+    isLegalDestination(_space, _cardLocation) {
+        return true;
+    }
+    beforeItemMove(move) {
+        if (isMoveItemType(MaterialType.EntityCard)(move)) {
+            if (move.location.type === LocationType.Pantheon) {
+                return this.onCardMoved(move);
+            }
+            else if (move.location.type === LocationType.PlayerDiscard) {
+                return this.onCardSacrificed(move);
+            }
+        }
+        return [];
+    }
+    onCardMoved(move) {
+        return [this.endPlayerTurn(move.location.player)];
+    }
+    onCardSacrificed(move) {
+        return [this.endPlayerTurn(move.location.player)];
+    }
+    getMovesAfterPlayersDone() {
+        this.updatePlayersGrids();
+        return super.getMovesAfterPlayersDone();
+    }
+    updatePlayersGrids() {
+        const events = [];
+        const triggerEffectsRule = new TriggerEffectsRule(this.game);
+        for (const player of triggerEffectsRule.getPlayersByEffectPriorityOrder()) {
+            const pantheon = new Pantheon(this.game, player);
+            events.push(...pantheon.updateGrid());
+        }
+        triggerEffectsRule.triggerEffects(...events);
+    }
+}

package/dist/material/entity/SimultaneousSacrificeEffectRule.d.ts

@@ -1,10 +1,10 @@
-import { ItemMove, Material, MaterialMove, MoveItem } from '@gamepark/rules-api';
-import { PlayerColor } from '../../PlayerColor';
-import { SimultaneousEffectRule } from './SimultaneousEffectRule';
-export declare abstract class SimultaneousSacrificeEffectRule extends SimultaneousEffectRule {
-    getActivePlayerLegalMoves(player: PlayerColor): MaterialMove[];
-    private getCardsAbleToSacrifice;
-    getCardsToSacrifice(player: PlayerColor): Material;
-    beforeItemMove(move: ItemMove): MaterialMove[];
-    onSacrifice(move: MoveItem): import("@gamepark/rules-api").EndPlayerTurn<number>[];
-}
+import { ItemMove, Material, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { PlayerColor } from '../../PlayerColor';
+import { SimultaneousEffectRule } from './SimultaneousEffectRule';
+export declare abstract class SimultaneousSacrificeEffectRule extends SimultaneousEffectRule {
+    getActivePlayerLegalMoves(player: PlayerColor): MaterialMove[];
+    private getCardsAbleToSacrifice;
+    getCardsToSacrifice(player: PlayerColor): Material;
+    beforeItemMove(move: ItemMove): MaterialMove[];
+    onSacrifice(move: MoveItem): import("@gamepark/rules-api").EndPlayerTurn<number>[];
+}

package/dist/material/entity/SimultaneousSacrificeEffectRule.js

@@ -1,55 +1,31 @@
-"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.SimultaneousSacrificeEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var PermanentEffectsRule_1 = require("../../rules/effects/PermanentEffectsRule");
-var LocationType_1 = require("../LocationType");
-var MaterialType_1 = require("../MaterialType");
-var Pantheon_1 = require("../Pantheon");
-var SimultaneousEffectRule_1 = require("./SimultaneousEffectRule");
-var SimultaneousSacrificeEffectRule = (function (_super) {
-    __extends(SimultaneousSacrificeEffectRule, _super);
-    function SimultaneousSacrificeEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    SimultaneousSacrificeEffectRule.prototype.getActivePlayerLegalMoves = function (player) {
-        var cards = this.getCardsAbleToSacrifice(player);
-        var moves = cards.moveItems({ type: LocationType_1.LocationType.PlayerDiscard, player: player });
-        var indexes = cards.getIndexes();
-        var replaceSacrifice = new Pantheon_1.Pantheon(this.game, player).replaceSacrifice(cards.getItems()).index(function (index) { return !indexes.includes(index); });
-        return moves.concat(replaceSacrifice.moveItems({ type: LocationType_1.LocationType.PlayerDiscard, player: player }));
-    };
-    SimultaneousSacrificeEffectRule.prototype.getCardsAbleToSacrifice = function (player) {
-        var rule = new PermanentEffectsRule_1.PermanentEffectsRule(this.game);
-        return this.getCardsToSacrifice(player).filter(function (card) { return rule.canSacrifice(card); });
-    };
-    SimultaneousSacrificeEffectRule.prototype.getCardsToSacrifice = function (player) {
-        return new Pantheon_1.Pantheon(this.game, player).visibleEntities;
-    };
-    SimultaneousSacrificeEffectRule.prototype.beforeItemMove = function (move) {
-        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.PlayerDiscard) {
-            return this.onSacrifice(move);
-        }
-        return [];
-    };
-    SimultaneousSacrificeEffectRule.prototype.onSacrifice = function (move) {
-        return [this.endPlayerTurn(move.location.player)];
-    };
-    return SimultaneousSacrificeEffectRule;
-}(SimultaneousEffectRule_1.SimultaneousEffectRule));
-exports.SimultaneousSacrificeEffectRule = SimultaneousSacrificeEffectRule;
+import { isMoveItemType } from '@gamepark/rules-api';
+import { PermanentEffectsRule } from '../../rules/effects/PermanentEffectsRule';
+import { LocationType } from '../LocationType';
+import { MaterialType } from '../MaterialType';
+import { Pantheon } from '../Pantheon';
+import { SimultaneousEffectRule } from './SimultaneousEffectRule';
+export class SimultaneousSacrificeEffectRule extends SimultaneousEffectRule {
+    getActivePlayerLegalMoves(player) {
+        const cards = this.getCardsAbleToSacrifice(player);
+        const moves = cards.moveItems({ type: LocationType.PlayerDiscard, player });
+        const indexes = cards.getIndexes();
+        const replaceSacrifice = new Pantheon(this.game, player).replaceSacrifice(cards.getItems()).index((index) => !indexes.includes(index));
+        return moves.concat(replaceSacrifice.moveItems({ type: LocationType.PlayerDiscard, player }));
+    }
+    getCardsAbleToSacrifice(player) {
+        const rule = new PermanentEffectsRule(this.game);
+        return this.getCardsToSacrifice(player).filter((card) => rule.canSacrifice(card));
+    }
+    getCardsToSacrifice(player) {
+        return new Pantheon(this.game, player).visibleEntities;
+    }
+    beforeItemMove(move) {
+        if (isMoveItemType(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
+            return this.onSacrifice(move);
+        }
+        return [];
+    }
+    onSacrifice(move) {
+        return [this.endPlayerTurn(move.location.player)];
+    }
+}

package/dist/material/entity/celtic/Banshee.d.ts

@@ -1,2 +1,2 @@
-import { EntityDescription } from '../EntityDescription';
-export declare const Banshee: EntityDescription;
+import { EntityDescription } from '../EntityDescription';
+export declare const Banshee: EntityDescription;