@gamepark/mythologies 0.3.1 → 0.4.1

package/dist/rules/effects/FairyEffectRule.js

@@ -0,0 +1,55 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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.FairyTargets, targets);
+        return _super.prototype.playEffect.call(this);
+    };
+    FairyEffectRule.prototype.getCardsToSacrifice = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).index(this.remind(Memory_1.Memory.FairyTargets)[0]);
+    };
+    FairyEffectRule.prototype.onSacrifice = function () {
+        var moves = [new Pantheon_1.Pantheon(this.game, this.player).gainGems(2)];
+        var targets = this.memorize(Memory_1.Memory.FairyTargets, 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.FairyTargets);
+        return [];
+    };
+    return FairyEffectRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.FairyEffectRule = FairyEffectRule;

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

@@ -0,0 +1,9 @@
+import { Location, Material, MaterialMove, 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[];
+}

package/dist/rules/effects/IdloziEffectRule.js

@@ -0,0 +1,43 @@
+"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.IdloziEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var IdloziEffectRule = (function (_super) {
+    __extends(IdloziEffectRule, _super);
+    function IdloziEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.IdloziEffect;
+        return _this;
+    }
+    IdloziEffectRule.prototype.getMovingCards = function (effectCardIndex) {
+        return _super.prototype.getMovingCards.call(this, effectCardIndex).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
+    };
+    IdloziEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
+        return space.y !== cardLocation.y;
+    };
+    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());
+    };
+    return IdloziEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.IdloziEffectRule = IdloziEffectRule;

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

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

package/dist/rules/effects/ImpunduluEffectRule.js

@@ -0,0 +1,47 @@
+"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.ImpunduluEffectRule = void 0;
+var Destiny_1 = require("../../material/Destiny");
+var Entity_1 = require("../../material/Entity");
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var ImpunduluEffectRule = (function (_super) {
+    __extends(ImpunduluEffectRule, _super);
+    function ImpunduluEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.ImpunduluEffect;
+        return _this;
+    }
+    ImpunduluEffectRule.prototype.playEffect = function () {
+        var player = this.card.location.player;
+        return new Pantheon_1.Pantheon(this.game, player).hasCrushed(this.card) ? _super.prototype.playEffect.call(this) : [];
+    };
+    ImpunduluEffectRule.prototype.getCardsToPlace = function () {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        var _a = this.card.location, x = _a.x, y = _a.y;
+        var crushed = pantheon.coveredEntities.location(function (l) { return l.x === x && l.y === y; }).maxBy(function (item) { return item.location.z; });
+        var mythology = (0, Entity_1.entityMythology)(crushed.getItem().id.front);
+        var board = this.material(MaterialType_1.MaterialType.MythologyBoard).id(function (id) { return id.mythology === mythology; });
+        return new Destiny_1.Destiny(this.game).cardsWithoutToken.location(LocationType_1.LocationType.SanctuaryCreatureSpot).parent(board.getIndex());
+    };
+    return ImpunduluEffectRule;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.ImpunduluEffectRule = ImpunduluEffectRule;

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

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

package/dist/rules/effects/InkosazanaEffectRule.js

@@ -0,0 +1,46 @@
+"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.InkosazanaEffectRule = void 0;
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var InkosazanaEffectRule = (function (_super) {
+    __extends(InkosazanaEffectRule, _super);
+    function InkosazanaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.InkosazanaEffect;
+        return _this;
+    }
+    InkosazanaEffectRule.prototype.onRuleStart = function () {
+        if (!this.remind(Memory_1.Memory.InkosazanaInvoke1)) {
+            this.remind(Memory_1.Memory.PendingEffects).unshift([this.getEffect()]);
+            this.memorize(Memory_1.Memory.InkosazanaInvoke1, true);
+        }
+        else {
+            this.forget(Memory_1.Memory.InkosazanaInvoke1);
+        }
+        return _super.prototype.onRuleStart.call(this);
+    };
+    InkosazanaEffectRule.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerDiscard).player(this.player);
+    };
+    return InkosazanaEffectRule;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.InkosazanaEffectRule = InkosazanaEffectRule;

package/dist/rules/effects/JiangshiEffectRule.js

@@ -47,6 +47,7 @@ var LocationType_1 = require("../../material/LocationType");
 var MaterialType_1 = require("../../material/MaterialType");
 var Pantheon_1 = require("../../material/Pantheon");
 var RuleId_1 = require("../RuleId");
+var PermanentEffectsRule_1 = require("./PermanentEffectsRule");
 var JiangshiEffectRule = (function (_super) {
     __extends(JiangshiEffectRule, _super);
     function JiangshiEffectRule() {
@@ -58,7 +59,8 @@ var JiangshiEffectRule = (function (_super) {
         var _this = this;
         var location = this.card.location;
         var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        var piles = pantheon.getPiles(function (space) { return space.y === location.y; });
+        var rule = new PermanentEffectsRule_1.PermanentEffectsRule(this.game);
+        var piles = pantheon.getPiles(function (space) { return space.y === location.y; }).filter(function (pile) { return rule.canSacrifice(pile.maxBy(function (item) { return item.location.z; }).getItem()); });
         return piles.map(function (pile) { return pile.moveItemsAtOnce({ type: LocationType_1.LocationType.PlayerDiscard, player: _this.player }); });
     };
     JiangshiEffectRule.prototype.beforeItemMove = function (move) {
@@ -67,7 +69,8 @@ var JiangshiEffectRule = (function (_super) {
             var topCard = this.material(MaterialType_1.MaterialType.EntityCard)
                 .index(move.indexes)
                 .maxBy(function (item) { return item.location.z; });
-            return __spreadArray(__spreadArray([pantheon.gainGems(2)], __read(pantheon.onEntitySacrificed(topCard)), false), __read(this.endEffect()), false);
+            pantheon.onEntitySacrificed(topCard);
+            return __spreadArray([pantheon.gainGems(2)], __read(this.endEffect()), false);
         }
         return [];
     };

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

@@ -0,0 +1,7 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { EntityItem } from '../../material/Entity';
+export declare class PermanentEffectsRule extends MaterialRulesPart {
+    canSacrifice(card: EntityItem): boolean;
+    canCrush(card: EntityItem): boolean;
+    canMove(card: EntityItem): boolean;
+}

package/dist/rules/effects/PermanentEffectsRule.js

@@ -0,0 +1,54 @@
+"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.PermanentEffectsRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/entity/Effect");
+var EntityDescription_1 = require("../../material/entity/EntityDescription");
+var Pantheon_1 = require("../../material/Pantheon");
+var PermanentEffectsRule = (function (_super) {
+    __extends(PermanentEffectsRule, _super);
+    function PermanentEffectsRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PermanentEffectsRule.prototype.canSacrifice = function (card) {
+        var _this = this;
+        return !this.game.players.some(function (player) {
+            return new Pantheon_1.Pantheon(_this.game, player).visibleEntities
+                .getItems()
+                .some(function (effectCard) { return (0, EntityDescription_1.getEffects)(effectCard.id.front).some(function (effect) { var _a; return !(0, Effect_1.isTriggeredEffect)(effect) && ((_a = effect.preventSacrifice) === null || _a === void 0 ? void 0 : _a.call(effect, card, effectCard)); }); });
+        });
+    };
+    PermanentEffectsRule.prototype.canCrush = function (card) {
+        var _this = this;
+        return !this.game.players.some(function (player) {
+            return new Pantheon_1.Pantheon(_this.game, player).visibleEntities
+                .getItems()
+                .some(function (effectCard) { return (0, EntityDescription_1.getEffects)(effectCard.id.front).some(function (effect) { var _a; return !(0, Effect_1.isTriggeredEffect)(effect) && ((_a = effect.preventCrush) === null || _a === void 0 ? void 0 : _a.call(effect, card, effectCard)); }); });
+        });
+    };
+    PermanentEffectsRule.prototype.canMove = function (card) {
+        var _this = this;
+        return !this.game.players.some(function (player) {
+            return new Pantheon_1.Pantheon(_this.game, player).visibleEntities
+                .getItems()
+                .some(function (effectCard) { return (0, EntityDescription_1.getEffects)(effectCard.id.front).some(function (effect) { var _a; return !(0, Effect_1.isTriggeredEffect)(effect) && ((_a = effect.preventMove) === null || _a === void 0 ? void 0 : _a.call(effect, card, effectCard)); }); });
+        });
+    };
+    return PermanentEffectsRule;
+}(rules_api_1.MaterialRulesPart));
+exports.PermanentEffectsRule = PermanentEffectsRule;

package/dist/rules/effects/QilinEffectRule.js

@@ -78,10 +78,9 @@ var QilinEffectRule = (function (_super) {
                     cardsToCopy.push.apply(cardsToCopy, __spreadArray([], __read(new Pantheon_1.Pantheon(this.game, player).visibleEntities
                         .location(function (l) { return l.x === _this.card.location.x; })
                         .id(function (id) {
-                        var _a;
-                        var entity = id.front;
-                        var trigger = (_a = EntityDescription_1.entities[entity].effect) === null || _a === void 0 ? void 0 : _a.trigger;
-                        return (0, Entity_1.isCreature)(entity) && trigger === Effect_1.isPlaced;
+                        return (0, Entity_1.isCreature)(id.front) &&
+                            id.front !== Entity_1.Entity.Qilin &&
+                            (0, EntityDescription_1.getEffects)(id.front).some(function (effect) { return (0, Effect_1.isTriggeredEffect)(effect) && effect.trigger === Effect_1.isPlaced; });
                     })
                         .getIndexes()), false));
                 }
@@ -99,7 +98,9 @@ var QilinEffectRule = (function (_super) {
     QilinEffectRule.prototype.onCustomMove = function (move) {
         if (move.type === CustomMoveType_1.CustomMoveType.ChooseEntityCard) {
             var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.data);
-            var effect = EntityDescription_1.entities[card.id.front].effect;
+            var effect = (0, EntityDescription_1.getEffects)(card.id.front)
+                .filter(Effect_1.isTriggeredEffect)
+                .find(function (effect) { return effect.trigger === Effect_1.isPlaced; });
             var moves = new effect.rule(this.game).playEffect();
             if (!moves.some(function (move) { return move.kind === rules_api_1.MoveKind.RulesMove; })) {
                 moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));

package/dist/rules/effects/ResolveEffectsRule.js

@@ -58,7 +58,7 @@ var ResolveEffectsRule = (function (_super) {
     ResolveEffectsRule.prototype.playEffect = function (pendingEffect) {
         this.memorize(Memory_1.Memory.OngoingEffect, pendingEffect);
         var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(pendingEffect.cardIndex);
-        var effect = EntityDescription_1.entities[card.id.front].effect;
+        var effect = (0, EntityDescription_1.getEffects)(card.id.front)[pendingEffect.effectIndex];
         if (effect.trigger === Effect_1.oncePerTurn) {
             this.memorize(Memory_1.Memory.OncePerTurn, function (indexes) {
                 if (indexes === void 0) { indexes = []; }

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

@@ -5,6 +5,6 @@ export declare class ShivaEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     canPlayEffect(cardIndex: number): boolean;
     onRuleStart(): MaterialMove[];
-    getPlayerMoves(): MaterialMove[];
+    getPlayerMoves(player?: number): MaterialMove[];
     beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
 }

package/dist/rules/effects/ShivaEffectRule.js

@@ -47,6 +47,7 @@ var LocationType_1 = require("../../material/LocationType");
 var MaterialType_1 = require("../../material/MaterialType");
 var Pantheon_1 = require("../../material/Pantheon");
 var RuleId_1 = require("../RuleId");
+var PermanentEffectsRule_1 = require("./PermanentEffectsRule");
 var ShivaEffectRule = (function (_super) {
     __extends(ShivaEffectRule, _super);
     function ShivaEffectRule() {
@@ -55,20 +56,22 @@ var ShivaEffectRule = (function (_super) {
         return _this;
     }
     ShivaEffectRule.prototype.canPlayEffect = function (cardIndex) {
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        var cards = pantheon.allCards;
-        var location = cards.getItem(cardIndex).location;
-        return pantheon.gems > 0 && cards.location(function (l) { return (0, rules_api_1.areAdjacentSquares)(l, location); }).length > 0;
+        var player = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location.player;
+        var pantheon = new Pantheon_1.Pantheon(this.game, player);
+        return pantheon.gems > 0 && this.getPlayerMoves(player).length > 0;
     };
     ShivaEffectRule.prototype.onRuleStart = function () {
         return [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
     };
-    ShivaEffectRule.prototype.getPlayerMoves = function () {
-        var _this = this;
+    ShivaEffectRule.prototype.getPlayerMoves = function (player) {
+        if (player === void 0) { player = this.player; }
         var location = this.card.location;
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        var piles = pantheon.getPiles(function (space) { return (0, rules_api_1.areAdjacentSquares)(space, location); });
-        return piles.map(function (pile) { return pile.moveItemsAtOnce({ type: LocationType_1.LocationType.PlayerDiscard, player: _this.player }); });
+        var pantheon = new Pantheon_1.Pantheon(this.game, player);
+        var rule = new PermanentEffectsRule_1.PermanentEffectsRule(this.game);
+        var piles = pantheon
+            .getPiles(function (space) { return (0, rules_api_1.areAdjacentSquares)(space, location); })
+            .filter(function (pile) { return rule.canSacrifice(pile.maxBy(function (item) { return item.location.z; }).getItem()); });
+        return piles.map(function (pile) { return pile.moveItemsAtOnce({ type: LocationType_1.LocationType.PlayerDiscard, player: player }); });
     };
     ShivaEffectRule.prototype.beforeItemMove = function (move) {
         if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.PlayerDiscard) {
@@ -76,7 +79,8 @@ var ShivaEffectRule = (function (_super) {
             var topCard = this.material(MaterialType_1.MaterialType.EntityCard)
                 .index(move.indexes)
                 .maxBy(function (item) { return item.location.z; });
-            return __spreadArray(__spreadArray([pantheon.gainFavor(move.indexes.length)], __read(pantheon.onEntitySacrificed(topCard)), false), __read(this.endEffect()), false);
+            pantheon.onEntitySacrificed(topCard);
+            return __spreadArray([pantheon.gainFavor(move.indexes.length)], __read(this.endEffect()), false);
         }
         return [];
     };

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

@@ -6,6 +6,6 @@ export declare class TriggerEffectsRule extends MaterialRulesPart {
     triggerPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): void;
     getPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): PendingEffect<TriggerEvent>[];
     triggerCardEffect(card: Material, triggerEvent: TriggerEvent): void;
-    getCardEffect(card: Material, triggerEvent: TriggerEvent): PendingEffect[];
+    getCardEffects(card: Material, triggerEvent: TriggerEvent): PendingEffect[];
     private getPlayersByEffectPriorityOrder;
 }

package/dist/rules/effects/TriggerEffectsRule.js

@@ -53,6 +53,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerEffectsRule = void 0;
 var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/entity/Effect");
 var EntityDescription_1 = require("../../material/entity/EntityDescription");
 var MaterialType_1 = require("../../material/MaterialType");
 var Pantheon_1 = require("../../material/Pantheon");
@@ -94,55 +95,72 @@ var TriggerEffectsRule = (function (_super) {
         }
     };
     TriggerEffectsRule.prototype.getPlayerEffects = function (player) {
-        var e_2, _a, e_3, _b;
+        var e_2, _a, e_3, _b, e_4, _c;
         var triggerEvents = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             triggerEvents[_i - 1] = arguments[_i];
         }
         var pendingEffects = [];
         var pantheon = new Pantheon_1.Pantheon(this.game, player);
-        var cards = pantheon.visibleEntities;
+        var material = this.material(MaterialType_1.MaterialType.EntityCard);
+        var cards = pantheon.visibleEntities.getIndexes();
         try {
             for (var triggerEvents_1 = __values(triggerEvents), triggerEvents_1_1 = triggerEvents_1.next(); !triggerEvents_1_1.done; triggerEvents_1_1 = triggerEvents_1.next()) {
-                var triggerEvent = triggerEvents_1_1.value;
+                var event = triggerEvents_1_1.value;
+                if (event.type === Effect_1.TriggerEventType.EntityCrushed && material.getItem(event.cardIndex).location.player === player && !cards.includes(event.cardIndex)) {
+                    cards.push(event.cardIndex);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (triggerEvents_1_1 && !triggerEvents_1_1.done && (_a = triggerEvents_1.return)) _a.call(triggerEvents_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var triggerEvents_2 = __values(triggerEvents), triggerEvents_2_1 = triggerEvents_2.next(); !triggerEvents_2_1.done; triggerEvents_2_1 = triggerEvents_2.next()) {
+                var triggerEvent = triggerEvents_2_1.value;
                 try {
-                    for (var _c = (e_3 = void 0, __values(cards.getIndexes())), _d = _c.next(); !_d.done; _d = _c.next()) {
-                        var cardIndex = _d.value;
-                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffect(cards.index(cardIndex), triggerEvent)), false));
+                    for (var cards_1 = (e_4 = void 0, __values(cards)), cards_1_1 = cards_1.next(); !cards_1_1.done; cards_1_1 = cards_1.next()) {
+                        var cardIndex = cards_1_1.value;
+                        var card = material.index(cardIndex);
+                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffects(card, triggerEvent)), false));
                     }
                 }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
                 finally {
                     try {
-                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        if (cards_1_1 && !cards_1_1.done && (_c = cards_1.return)) _c.call(cards_1);
                     }
-                    finally { if (e_3) throw e_3.error; }
+                    finally { if (e_4) throw e_4.error; }
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
-                if (triggerEvents_1_1 && !triggerEvents_1_1.done && (_a = triggerEvents_1.return)) _a.call(triggerEvents_1);
+                if (triggerEvents_2_1 && !triggerEvents_2_1.done && (_b = triggerEvents_2.return)) _b.call(triggerEvents_2);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         return pendingEffects;
     };
     TriggerEffectsRule.prototype.triggerCardEffect = function (card, triggerEvent) {
-        var pendingEffects = this.getCardEffect(card, triggerEvent);
+        var pendingEffects = this.getCardEffects(card, triggerEvent);
         if (pendingEffects.length) {
             this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
         }
     };
-    TriggerEffectsRule.prototype.getCardEffect = function (card, triggerEvent) {
+    TriggerEffectsRule.prototype.getCardEffects = function (card, triggerEvent) {
         var pendingEffects = [];
         var cardIndex = card.getIndex();
         var cardItem = card.getItem();
-        if (cardItem.id.front) {
-            var effect = EntityDescription_1.entities[cardItem.id.front].effect;
-            if (effect === null || effect === void 0 ? void 0 : effect.trigger(triggerEvent, card, this.game)) {
-                pendingEffects.push({ cardIndex: cardIndex, triggerEvent: triggerEvent, auto: !!effect.auto });
+        for (var effectIndex = 0; effectIndex < (0, EntityDescription_1.getEffects)(cardItem.id.front).length; effectIndex++) {
+            var effect = (0, EntityDescription_1.getEffects)(cardItem.id.front)[effectIndex];
+            if ((0, Effect_1.isTriggeredEffect)(effect) && effect.trigger(triggerEvent, card, this.game)) {
+                pendingEffects.push({ cardIndex: cardIndex, effectIndex: effectIndex, triggerEvent: triggerEvent, auto: !!effect.auto });
             }
         }
         return pendingEffects;

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

@@ -0,0 +1,11 @@
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class WerehyenaEffectRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(): import("@gamepark/rules-api").StartRule<RuleId.WerehyenaCallEffect>[];
+}
+export declare class WerehyenaCallEffectRule extends PlaceCardEffectRule {
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/WerehyenaEffectRule.js

@@ -0,0 +1,54 @@
+"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.WerehyenaCallEffectRule = exports.WerehyenaEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var RuleId_1 = require("../RuleId");
+var WerehyenaEffectRule = (function (_super) {
+    __extends(WerehyenaEffectRule, _super);
+    function WerehyenaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.WerehyenaEffect;
+        return _this;
+    }
+    WerehyenaEffectRule.prototype.getCardsToSacrifice = function () {
+        return _super.prototype.getCardsToSacrifice.call(this).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
+    };
+    WerehyenaEffectRule.prototype.onSacrifice = function () {
+        return [this.startRule(RuleId_1.RuleId.WerehyenaCallEffect)];
+    };
+    return WerehyenaEffectRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.WerehyenaEffectRule = WerehyenaEffectRule;
+var WerehyenaCallEffectRule = (function (_super) {
+    __extends(WerehyenaCallEffectRule, _super);
+    function WerehyenaCallEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WerehyenaCallEffectRule.prototype.getCardsToPlace = function () {
+        var _this = this;
+        return this.material(MaterialType_1.MaterialType.EntityCard)
+            .location(LocationType_1.LocationType.PlayerDiscard)
+            .player(function (player) { return player !== _this.player; });
+    };
+    return WerehyenaCallEffectRule;
+}(PlaceCardEffectRule_1.PlaceCardEffectRule));
+exports.WerehyenaCallEffectRule = WerehyenaCallEffectRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -29,5 +29,5 @@
     "i18next": "^22.0.3",
     "lodash": "^4.17.21"
   },
-  "gitHead": "9e3481a061f2f707eb6ed6c340dd043ae264d6ad"
+  "gitHead": "d8c1359afbcb56757b75fda229d3a030a64b4d8b"
 }