@gamepark/mythologies 0.10.0 → 0.12.0

package/dist/rules/effects/LeprechaunEffectRule.js

@@ -1,49 +1,23 @@
-"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.LeprechaunEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var PlayerEffectRule_1 = require("../../material/entity/PlayerEffectRule");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var RuleId_1 = require("../RuleId");
-var LeprechaunEffectRule = (function (_super) {
-    __extends(LeprechaunEffectRule, _super);
-    function LeprechaunEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.LeprechaunEffect;
-        return _this;
-    }
-    LeprechaunEffectRule.prototype.canPlayEffect = function (cardIndex) {
-        return this.getPlayerMoves(cardIndex).length > 0;
-    };
-    LeprechaunEffectRule.prototype.getPlayerMoves = function (cardIndex) {
-        if (cardIndex === void 0) { cardIndex = this.getEffect().cardIndex; }
-        var _a = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location, x = _a.x, y = _a.y, player = _a.player;
-        var pantheon = new Pantheon_1.Pantheon(this.game, player);
-        return pantheon.gainLineBonus(y).concat(pantheon.gainColumnBonus(x));
-    };
-    LeprechaunEffectRule.prototype.afterItemMove = function (move) {
-        if ((0, rules_api_1.isMoveItem)(move) && (move.itemType === MaterialType_1.MaterialType.GemToken || move.itemType === MaterialType_1.MaterialType.FavorToken)) {
-            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-        }
-        return [];
-    };
-    return LeprechaunEffectRule;
-}(PlayerEffectRule_1.PlayerEffectRule));
-exports.LeprechaunEffectRule = LeprechaunEffectRule;
+import { isMoveItem } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { RuleId } from '../RuleId';
+export class LeprechaunEffectRule extends PlayerEffectRule {
+    ruleId = RuleId.LeprechaunEffect;
+    canPlayEffect(cardIndex) {
+        return this.getPlayerMoves(cardIndex).length > 0;
+    }
+    getPlayerMoves(cardIndex = this.getEffect().cardIndex) {
+        const { x, y, player } = this.material(MaterialType.EntityCard).getItem(cardIndex).location;
+        const pantheon = new Pantheon(this.game, player);
+        return pantheon.gainLineBonus(y).concat(pantheon.gainColumnBonus(x));
+    }
+    afterItemMove(move) {
+        if (isMoveItem(move) && (move.itemType === MaterialType.GemToken || move.itemType === MaterialType.FavorToken)) {
+            return [this.customMove(CustomMoveType.EndEffect)];
+        }
+        return [];
+    }
+}

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

@@ -1,11 +1,11 @@
-import { Location, XYCoordinates } from '@gamepark/rules-api';
-import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
-import { PlayerColor } from '../../PlayerColor';
-import { RuleId } from '../RuleId';
-export declare class MinotaurEffectRule extends SimultaneousMoveEffectRule {
-    ruleId: RuleId;
-    onRuleStart(): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
-    getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
-    onRuleEnd(): never[];
-}
+import { Location, XYCoordinates } from '@gamepark/rules-api';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class MinotaurEffectRule extends SimultaneousMoveEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+    getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
+    onRuleEnd(): never[];
+}

package/dist/rules/effects/MinotaurEffectRule.js

@@ -1,49 +1,23 @@
-"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.MinotaurEffectRule = void 0;
-var Entity_1 = require("../../material/Entity");
-var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
-var Pantheon_1 = require("../../material/Pantheon");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var MinotaurEffectRule = (function (_super) {
-    __extends(MinotaurEffectRule, _super);
-    function MinotaurEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.MinotaurEffect;
-        return _this;
-    }
-    MinotaurEffectRule.prototype.onRuleStart = function () {
-        this.memorize(Memory_1.Memory.TargetPlane, this.card.location.x);
-        return _super.prototype.onRuleStart.call(this);
-    };
-    MinotaurEffectRule.prototype.getMovingCards = function (player) {
-        var _a;
-        var column = (_a = this.remind(Memory_1.Memory.TargetPlane)) !== null && _a !== void 0 ? _a : this.card.location.x;
-        return new Pantheon_1.Pantheon(this.game, player).visibleEntities.location(function (l) { return l.x === column; }).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
-    };
-    MinotaurEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
-        return space.y === cardLocation.y;
-    };
-    MinotaurEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.TargetPlane);
-        return [];
-    };
-    return MinotaurEffectRule;
-}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
-exports.MinotaurEffectRule = MinotaurEffectRule;
+import { isCreature } from '../../material/Entity';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class MinotaurEffectRule extends SimultaneousMoveEffectRule {
+    ruleId = RuleId.MinotaurEffect;
+    onRuleStart() {
+        this.memorize(Memory.TargetPlane, this.card.location.x);
+        return super.onRuleStart();
+    }
+    getMovingCards(player) {
+        const column = this.remind(Memory.TargetPlane) ?? this.card.location.x;
+        return new Pantheon(this.game, player).visibleEntities.location((l) => l.x === column).id((id) => isCreature(id.front));
+    }
+    isLegalDestination(space, cardLocation) {
+        return space.y === cardLocation.y;
+    }
+    onRuleEnd() {
+        this.forget(Memory.TargetPlane);
+        return [];
+    }
+}

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

@@ -1,14 +1,15 @@
-import { MaterialMove, MoveItem } from '@gamepark/rules-api';
-import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
-import { PlayerColor } from '../../PlayerColor';
-export declare abstract class MultipleSimultaneousMoveEffectRule extends SimultaneousMoveEffectRule {
-    playEffect(): MaterialMove[];
-    getTargetEntitiesAbleToMove(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    getTargetEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    getEffectCount(player: PlayerColor): number;
-    getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    onCardMoved(move: MoveItem): import("@gamepark/rules-api").EndPlayerTurn<number>[];
-    onCardSacrificed(move: MoveItem): MaterialMove[];
-    onRuleEnd(): never[];
-    updatePlayersGrids(): MoveItem[];
-}
+import { MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+export declare abstract class MultipleSimultaneousMoveEffectRule extends SimultaneousMoveEffectRule {
+    playEffect(): MaterialMove[];
+    getTargetEntitiesAbleToMove(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getTargetEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getEffectCount(player: PlayerColor): number;
+    getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    onCardMoved(move: MoveItem): import("@gamepark/rules-api").EndPlayerTurn<number>[];
+    onCardSacrificed(move: MoveItem): MaterialMove[];
+    onRuleEnd(): never[];
+    getMovesAfterPlayersDone(): MaterialMove[];
+    collectOpponentBonuses(): MoveItem[];
+}

package/dist/rules/effects/MultipleSimultaneousMoveEffectRule.js

@@ -1,144 +1,96 @@
-"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.MultipleSimultaneousMoveEffectRule = void 0;
-var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
-var LocationType_1 = require("../../material/LocationType");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var Memory_1 = require("../../Memory");
-var MultipleSimultaneousMoveEffectRule = (function (_super) {
-    __extends(MultipleSimultaneousMoveEffectRule, _super);
-    function MultipleSimultaneousMoveEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MultipleSimultaneousMoveEffectRule.prototype.playEffect = function () {
-        var e_1, _a;
-        var _this = this;
-        var moves = [];
-        var playersToActivate = [];
-        var _loop_1 = function (player) {
-            var e_2, _d;
-            var effectCount = this_1.getEffectCount(player);
-            var targetEntities = this_1.getTargetEntitiesAbleToMove(player);
-            var pantheon = new Pantheon_1.Pantheon(this_1.game, player);
-            var canSacrificeToPreventMove = targetEntities.length > 0 && effectCount > 0 && pantheon.sacrificeToPreventMove().length > 0;
-            if (canSacrificeToPreventMove ||
-                effectCount < targetEntities.length ||
-                targetEntities.getItems().some(function (entity) { return _this.getAvailableDestinations(player, entity).length > 1; })) {
-                this_1.memorize(Memory_1.Memory.TargetEntities, targetEntities.getIndexes(), player);
-                this_1.memorize(Memory_1.Memory.EffectCount, effectCount, player);
-                playersToActivate.push(player);
-            }
-            else {
-                try {
-                    for (var _e = (e_2 = void 0, __values(targetEntities.getIndexes())), _f = _e.next(); !_f.done; _f = _e.next()) {
-                        var index = _f.value;
-                        var card = targetEntities.index(index);
-                        var destinations = this_1.getAvailableDestinations(player, card.getItem());
-                        if (destinations.length) {
-                            var _g = destinations[0], x = _g.x, y = _g.y;
-                            moves.push(card.moveItem({ type: LocationType_1.LocationType.Pantheon, player: player, x: x, y: y }));
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_f && !_f.done && (_d = _e.return)) _d.call(_e);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-        };
-        var this_1 = this;
-        try {
-            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                _loop_1(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;
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.getTargetEntitiesAbleToMove = function (player) {
-        var pantheon = new Pantheon_1.Pantheon(this.game, player);
-        return this.getTargetEntities(player).filter(function (item) { return pantheon.isAbleToMove(item); });
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.getTargetEntities = function (player) {
-        var pantheon = new Pantheon_1.Pantheon(this.game, player);
-        return pantheon.visibleEntities;
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.getEffectCount = function (player) {
-        return this.getTargetEntitiesAbleToMove(player).length;
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.getMovingCards = function (player) {
-        return this.material(MaterialType_1.MaterialType.EntityCard).index(this.remind(Memory_1.Memory.TargetEntities, player));
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.onCardMoved = function (move) {
-        this.memorize(Memory_1.Memory.TargetEntities, function (entities) { return entities.filter(function (index) { return index !== move.itemIndex; }); }, move.location.player);
-        var count = this.memorize(Memory_1.Memory.EffectCount, function (count) { return count - 1; }, move.location.player);
-        return count ? [] : [this.endPlayerTurn(move.location.player)];
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.onCardSacrificed = function (move) {
-        return this.onCardMoved(move);
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.TargetEntities);
-        this.forget(Memory_1.Memory.EffectCount);
-        return [];
-    };
-    MultipleSimultaneousMoveEffectRule.prototype.updatePlayersGrids = function () {
-        var e_3, _a;
-        var gainBonusMoves = _super.prototype.updatePlayersGrids.call(this);
-        var cardOwner = this.card.location.player;
-        try {
-            for (var gainBonusMoves_1 = __values(gainBonusMoves), gainBonusMoves_1_1 = gainBonusMoves_1.next(); !gainBonusMoves_1_1.done; gainBonusMoves_1_1 = gainBonusMoves_1.next()) {
-                var gainBonusMove = gainBonusMoves_1_1.value;
-                gainBonusMove.location.player = cardOwner;
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (gainBonusMoves_1_1 && !gainBonusMoves_1_1.done && (_a = gainBonusMoves_1.return)) _a.call(gainBonusMoves_1);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        return gainBonusMoves;
-    };
-    return MultipleSimultaneousMoveEffectRule;
-}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
-exports.MultipleSimultaneousMoveEffectRule = MultipleSimultaneousMoveEffectRule;
+import { partition } from 'es-toolkit';
+import { CustomMoveType } from '../../CustomMoveType';
+import { PendingEffectsType } from '../../material/entity/Effect';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { LocationType } from '../../material/LocationType';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+export class MultipleSimultaneousMoveEffectRule extends SimultaneousMoveEffectRule {
+    playEffect() {
+        const moves = [];
+        const playersToActivate = [];
+        for (const player of this.game.players) {
+            const effectCount = this.getEffectCount(player);
+            const targetEntities = this.getTargetEntitiesAbleToMove(player);
+            const pantheon = new Pantheon(this.game, player);
+            const canSacrificeToPreventMove = targetEntities.length > 0 && effectCount > 0 && pantheon.sacrificeToPreventMove().length > 0;
+            if (canSacrificeToPreventMove ||
+                effectCount < targetEntities.length ||
+                targetEntities.getItems().some((entity) => this.getAvailableDestinations(player, entity).length > 1)) {
+                this.memorize(Memory.TargetEntities, targetEntities.getIndexes(), player);
+                this.memorize(Memory.EffectCount, effectCount, player);
+                playersToActivate.push(player);
+            }
+            else {
+                for (const index of targetEntities.getIndexes()) {
+                    const card = targetEntities.index(index);
+                    const destinations = this.getAvailableDestinations(player, card.getItem());
+                    if (destinations.length) {
+                        const { x, y } = destinations[0];
+                        moves.push(card.moveItem({ type: LocationType.Pantheon, player, x, y }));
+                    }
+                }
+            }
+        }
+        moves.push(this.startSimultaneousRule(this.ruleId, playersToActivate));
+        return moves;
+    }
+    getTargetEntitiesAbleToMove(player) {
+        const pantheon = new Pantheon(this.game, player);
+        return this.getTargetEntities(player).filter((item) => pantheon.isAbleToMove(item));
+    }
+    getTargetEntities(player) {
+        const pantheon = new Pantheon(this.game, player);
+        return pantheon.visibleEntities;
+    }
+    getEffectCount(player) {
+        return this.getTargetEntitiesAbleToMove(player).length;
+    }
+    getMovingCards(player) {
+        return this.material(MaterialType.EntityCard).index(this.remind(Memory.TargetEntities, player));
+    }
+    onCardMoved(move) {
+        this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex), move.location.player);
+        const count = this.memorize(Memory.EffectCount, (count) => count - 1, move.location.player);
+        return count ? [] : [this.endPlayerTurn(move.location.player)];
+    }
+    onCardSacrificed(move) {
+        return this.onCardMoved(move);
+    }
+    onRuleEnd() {
+        this.forget(Memory.TargetEntities);
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+    getMovesAfterPlayersDone() {
+        this.updatePlayersGrids();
+        return [...this.collectOpponentBonuses(), this.customMove(CustomMoveType.EndEffect)];
+    }
+    collectOpponentBonuses() {
+        const moves = [];
+        const cardOwner = this.card.location.player;
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        const [bonusGains, otherEffects] = partition(pendingEffects, (effect) => effect.type === PendingEffectsType.BonusGains && effect.player !== cardOwner);
+        this.memorize(Memory.PendingEffects, otherEffects);
+        for (const bonusGain of bonusGains) {
+            if (bonusGain.type === PendingEffectsType.BonusGains) {
+                for (const y of bonusGain.lines) {
+                    moves.push(this.material(MaterialType.GemToken)
+                        .location(LocationType.PantheonLineBonus)
+                        .player(bonusGain.player)
+                        .location((l) => l.y === y)
+                        .moveItem({ type: LocationType.PlayerGems, player: cardOwner }));
+                }
+                for (const x of bonusGain.columns) {
+                    moves.push(this.material(MaterialType.FavorToken)
+                        .location(LocationType.PantheonColumnBonus)
+                        .player(bonusGain.player)
+                        .location((l) => l.x === x)
+                        .moveItem({ type: LocationType.PlayerFavor, player: cardOwner }));
+                }
+            }
+        }
+        return moves;
+    }
+}

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

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