@gamepark/mythologies 0.4.1 → 0.5.1

package/dist/rules/effects/GorgonEffectRule.js

@@ -14,33 +14,9 @@ var __extends = (this && this.__extends) || (function () {
         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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GorgonEffectRule = void 0;
+var CustomMoveType_1 = require("../../CustomMoveType");
 var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
 var Pantheon_1 = require("../../material/Pantheon");
 var RuleId_1 = require("../RuleId");
@@ -57,7 +33,7 @@ var GorgonEffectRule = (function (_super) {
     };
     GorgonEffectRule.prototype.onSacrifice = function () {
         var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        return __spreadArray([pantheon.gainGems(2)], __read(this.endEffect()), false);
+        return [pantheon.gainGems(2), this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
     };
     return GorgonEffectRule;
 }(SacrificeEffectRule_1.SacrificeEffectRule));

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

@@ -1,5 +1,9 @@
-import { MaterialMove } from '@gamepark/rules-api';
-import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
-export declare class HadesEffectRule extends SimultaneousMoveEffectRule {
-    playEffect(): MaterialMove[];
+import { Location, XYCoordinates } from '@gamepark/rules-api';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+import { MultipleSimultaneousMoveEffectRule } from './MultipleSimultaneousMoveEffectRule';
+export declare class HadesEffectRule extends MultipleSimultaneousMoveEffectRule {
+    ruleId: RuleId;
+    getTargetEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
 }

package/dist/rules/effects/HadesEffectRule.js

@@ -14,64 +14,26 @@ var __extends = (this && this.__extends) || (function () {
         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.HadesEffectRule = void 0;
 var Entity_1 = require("../../material/Entity");
-var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
-var LocationType_1 = require("../../material/LocationType");
 var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var MultipleSimultaneousMoveEffectRule_1 = require("./MultipleSimultaneousMoveEffectRule");
 var HadesEffectRule = (function (_super) {
     __extends(HadesEffectRule, _super);
     function HadesEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.HadesEffect;
+        return _this;
     }
-    HadesEffectRule.prototype.playEffect = function () {
-        var e_1, _a, e_2, _b;
-        var moves = [];
-        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);
-                var entities = pantheon.visibleEntities;
-                try {
-                    for (var _e = (e_2 = void 0, __values(entities.getIndexes())), _f = _e.next(); !_f.done; _f = _e.next()) {
-                        var index = _f.value;
-                        var entity = entities.getItem(index);
-                        var _g = entity.location, x = _g.x, y = _g.y;
-                        if (y !== 2 && !(0, Entity_1.isGod)(entity.id.front) && pantheon.isFreeSpace({ x: x, y: y + 1 })) {
-                            moves.push(entities.index(index).moveItem({ type: LocationType_1.LocationType.Pantheon, player: player, x: x, y: y + 1 }));
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-        }
-        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; }
-        }
-        return moves;
+    HadesEffectRule.prototype.getTargetEntities = function (player) {
+        var pantheon = new Pantheon_1.Pantheon(this.game, player);
+        return pantheon.visibleEntities.id(function (id) { return !(0, Entity_1.isGod)(id.front); }).location(function (l) { return l.y < 2 && pantheon.isFreeSpace({ x: l.x, y: l.y + 1 }); });
+    };
+    HadesEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
+        return cardLocation.x === space.x && cardLocation.y === space.y - 1;
     };
     return HadesEffectRule;
-}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
+}(MultipleSimultaneousMoveEffectRule_1.MultipleSimultaneousMoveEffectRule));
 exports.HadesEffectRule = HadesEffectRule;

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

@@ -1,9 +1,9 @@
-import { Location, Material, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
+import { Location, Material, MoveItem, XYCoordinates } from '@gamepark/rules-api';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { RuleId } from '../RuleId';
 export declare class IdloziEffectRule extends MoveEffectRule {
     ruleId: RuleId;
     getMovingCards(effectCardIndex: number): Material;
     isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
-    onCardMoved(move: MoveItem): MaterialMove[];
+    onCardMoved(move: MoveItem): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
 }

package/dist/rules/effects/IdloziEffectRule.js

@@ -16,6 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdloziEffectRule = void 0;
+var CustomMoveType_1 = require("../../CustomMoveType");
 var Entity_1 = require("../../material/Entity");
 var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
 var MaterialType_1 = require("../../material/MaterialType");
@@ -36,7 +37,9 @@ var IdloziEffectRule = (function (_super) {
     };
     IdloziEffectRule.prototype.onCardMoved = function (move) {
         var entity = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).id.front;
-        return new Pantheon_1.Pantheon(this.game, this.player).getInvokeGains(entity, move.location.y).concat(this.endEffect());
+        var moves = new Pantheon_1.Pantheon(this.game, this.player).getInvokeGains(entity, move.location.y);
+        moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+        return moves;
     };
     return IdloziEffectRule;
 }(MoveEffectRule_1.MoveEffectRule));

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

@@ -6,7 +6,7 @@ import { RuleId } from '../RuleId';
 export declare class IllapaEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     getPlayerMoves(): CustomMove<number>[];
-    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+    onCustomMove(move: CustomMove): CustomMove<number>[] | import("@gamepark/rules-api").StartSimultaneousRule<number, RuleId.IllapaSacrifice>[];
     getPlayersHavingToSacrifice(line: number): number[];
 }
 export declare class IllapaSacrificeRule extends SimultaneousSacrificeEffectRule {

package/dist/rules/effects/IllapaEffectRule.js

@@ -37,13 +37,13 @@ var IllapaEffectRule = (function (_super) {
     };
     IllapaEffectRule.prototype.onCustomMove = function (move) {
         if (move.type === CustomMoveType_1.CustomMoveType.ChooseLine) {
-            this.memorize(Memory_1.Memory.IllapaLine, move.data);
+            this.memorize(Memory_1.Memory.TargetLine, move.data);
             var players = this.getPlayersHavingToSacrifice(move.data);
             if (players.length) {
                 return [this.startSimultaneousRule(RuleId_1.RuleId.IllapaSacrifice, players)];
             }
             else {
-                return _super.prototype.endEffect.call(this);
+                return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
             }
         }
         return [];
@@ -61,7 +61,7 @@ var IllapaSacrificeRule = (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     IllapaSacrificeRule.prototype.getCardsToSacrifice = function (player) {
-        var line = this.remind(Memory_1.Memory.IllapaLine);
+        var line = this.remind(Memory_1.Memory.TargetLine);
         return _super.prototype.getCardsToSacrifice.call(this, player)
             .id(function (id) { return (0, Entity_1.isCreature)(id.front); })
             .location(function (l) { return l.y === line; });

package/dist/rules/effects/InkosazanaEffectRule.js

@@ -29,12 +29,12 @@ var InkosazanaEffectRule = (function (_super) {
         return _this;
     }
     InkosazanaEffectRule.prototype.onRuleStart = function () {
-        if (!this.remind(Memory_1.Memory.InkosazanaInvoke1)) {
+        if (!this.remind(Memory_1.Memory.EffectCount)) {
             this.remind(Memory_1.Memory.PendingEffects).unshift([this.getEffect()]);
-            this.memorize(Memory_1.Memory.InkosazanaInvoke1, true);
+            this.memorize(Memory_1.Memory.EffectCount, true);
         }
         else {
-            this.forget(Memory_1.Memory.InkosazanaInvoke1);
+            this.forget(Memory_1.Memory.EffectCount);
         }
         return _super.prototype.onRuleStart.call(this);
     };

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

@@ -4,5 +4,5 @@ import { RuleId } from '../RuleId';
 export declare class JiangshiEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     getPlayerMoves(): MaterialMove[];
-    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CustomMove<number> | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
 }

package/dist/rules/effects/JiangshiEffectRule.js

@@ -14,34 +14,10 @@ var __extends = (this && this.__extends) || (function () {
         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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JiangshiEffectRule = 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 MaterialType_1 = require("../../material/MaterialType");
@@ -70,7 +46,7 @@ var JiangshiEffectRule = (function (_super) {
                 .index(move.indexes)
                 .maxBy(function (item) { return item.location.z; });
             pantheon.onEntitySacrificed(topCard);
-            return __spreadArray([pantheon.gainGems(2)], __read(this.endEffect()), false);
+            return [pantheon.gainGems(2), this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
         }
         return [];
     };

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

@@ -0,0 +1,9 @@
+import { ItemMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { RuleId } from '../RuleId';
+export declare class LeprechaunEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove<number>[];
+}

package/dist/rules/effects/LeprechaunEffectRule.js

@@ -0,0 +1,49 @@
+"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 Effect_1 = require("../../material/entity/Effect");
+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;
+}(Effect_1.PlayerEffectRule));
+exports.LeprechaunEffectRule = LeprechaunEffectRule;

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

@@ -0,0 +1,13 @@
+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[];
+}

package/dist/rules/effects/MultipleSimultaneousMoveEffectRule.js

@@ -0,0 +1,160 @@
+"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.MultipleSimultaneousMoveEffectRule = void 0;
+var Effect_1 = require("../../material/entity/Effect");
+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 TriggerEffectsRule_1 = require("./TriggerEffectsRule");
+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; }
+        }
+        if (this.ruleId && playersToActivate.length) {
+            moves.push(this.startSimultaneousRule(this.ruleId, playersToActivate));
+        }
+        else {
+            moves.push.apply(moves, __spreadArray([], __read(this.updatePlayersGrids()), false));
+        }
+        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) {
+        var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex);
+        new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.EntitySacrificed, card: card.getItem(), cardIndex: card.getIndex() });
+        return this.onCardMoved(move);
+    };
+    MultipleSimultaneousMoveEffectRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.EntityMoved);
+        this.forget(Memory_1.Memory.TargetEntities);
+        this.forget(Memory_1.Memory.EffectCount);
+        return [];
+    };
+    return MultipleSimultaneousMoveEffectRule;
+}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
+exports.MultipleSimultaneousMoveEffectRule = MultipleSimultaneousMoveEffectRule;

package/dist/rules/effects/NuwaEffectRule.js

@@ -51,7 +51,7 @@ var NuwaEffectRule = (function (_super) {
                 if (this.isOpponent(player)) {
                     var creatures = new Pantheon_1.Pantheon(this.game, player).visibleEntities.id(function (id) { return (0, Entity_1.isCreature)(id.front); }).getIndexes();
                     if (creatures.length > 0) {
-                        this.memorize(Memory_1.Memory.NuwaPlayerCreatures, creatures, player);
+                        this.memorize(Memory_1.Memory.TargetEntities, creatures, player);
                         players.push(player);
                     }
                 }
@@ -69,18 +69,18 @@ var NuwaEffectRule = (function (_super) {
     NuwaEffectRule.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 creatures = this.remind(Memory_1.Memory.NuwaPlayerCreatures, player);
+        var creatures = this.remind(Memory_1.Memory.TargetEntities, player);
         if (gems.getQuantity() >= creatures.length) {
             moves.push(gems.moveItem({ type: LocationType_1.LocationType.PlayerGems, player: this.card.location.player }, creatures.length));
         }
         return moves;
     };
     NuwaEffectRule.prototype.getCardsToSacrifice = function (player) {
-        return _super.prototype.getCardsToSacrifice.call(this, player).index(this.remind(Memory_1.Memory.NuwaPlayerCreatures, player));
+        return _super.prototype.getCardsToSacrifice.call(this, player).index(this.remind(Memory_1.Memory.TargetEntities, player));
     };
     NuwaEffectRule.prototype.onSacrifice = function (move) {
         var player = move.location.player;
-        var creaturesLeft = this.memorize(Memory_1.Memory.NuwaPlayerCreatures, function (creatures) { return creatures.filter(function (c) { return c !== move.itemIndex; }); }, player);
+        var creaturesLeft = this.memorize(Memory_1.Memory.TargetEntities, function (creatures) { return creatures.filter(function (c) { return c !== move.itemIndex; }); }, player);
         return creaturesLeft.length ? [] : [this.endPlayerTurn(player)];
     };
     NuwaEffectRule.prototype.beforeItemMove = function (move) {

package/dist/rules/effects/OdinEffectRule.js

@@ -37,14 +37,14 @@ var OdinEffectRule = (function (_super) {
     };
     OdinEffectRule.prototype.onCustomMove = function (move) {
         if (move.type === CustomMoveType_1.CustomMoveType.ChooseMythology) {
-            this.memorize(Memory_1.Memory.OdinTargetMythology, move.data);
+            this.memorize(Memory_1.Memory.TargetMythology, move.data);
             return [this.startRule(RuleId_1.RuleId.DrawDestinyCard)];
         }
         return [];
     };
     OdinEffectRule.prototype.isCardRestricted = function (card, player) {
         return ((card.location.type === LocationType_1.LocationType.SanctuaryCreatureSpot || card.location.type === LocationType_1.LocationType.SanctuaryGodSpot) &&
-            (0, Entity_1.entityMythology)(card.id.front) === this.remind(Memory_1.Memory.OdinTargetMythology) &&
+            (0, Entity_1.entityMythology)(card.id.front) === this.remind(Memory_1.Memory.TargetMythology) &&
             (!player || !new Pantheon_1.Pantheon(this.game, player).hasEntity(Entity_1.Entity.Odin)));
     };
     return OdinEffectRule;

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

@@ -1,5 +1,9 @@
-import { MaterialMove } from '@gamepark/rules-api';
-import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
-export declare class RaEffectRule extends SimultaneousMoveEffectRule {
-    playEffect(): MaterialMove[];
+import { Location, XYCoordinates } from '@gamepark/rules-api';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+import { MultipleSimultaneousMoveEffectRule } from './MultipleSimultaneousMoveEffectRule';
+export declare class RaEffectRule extends MultipleSimultaneousMoveEffectRule {
+    ruleId: RuleId;
+    getTargetEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
 }