@gamepark/mythologies 0.9.3 → 0.11.0

package/dist/rules/effects/TriggerEffectsRule.js

@@ -1,183 +1,65 @@
-"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.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");
-var Memory_1 = require("../../Memory");
-var TriggerEffectsRule = (function (_super) {
-    __extends(TriggerEffectsRule, _super);
-    function TriggerEffectsRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TriggerEffectsRule.prototype.triggerEffects = function () {
-        var e_1, _a;
-        var triggerEvents = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            triggerEvents[_i] = arguments[_i];
-        }
-        var players = this.getPlayersByEffectPriorityOrder();
-        try {
-            for (var _b = __values(players.reverse()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                this.triggerPlayerEffects.apply(this, __spreadArray([player], __read(triggerEvents), false));
-            }
-        }
-        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; }
-        }
-    };
-    TriggerEffectsRule.prototype.triggerPlayerEffects = function (player) {
-        var triggerEvents = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            triggerEvents[_i - 1] = arguments[_i];
-        }
-        var pendingEffects = this.getPlayerEffects.apply(this, __spreadArray([player], __read(triggerEvents), false));
-        if (pendingEffects.length) {
-            this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
-        }
-    };
-    TriggerEffectsRule.prototype.getPlayerEffects = function (player) {
-        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 material = this.material(MaterialType_1.MaterialType.EntityCard);
-        var cards = pantheon.visibleEntities.getIndexes().map(function (index) { return ({ index: index, location: material.getItem(index).location }); });
-        var _loop_1 = function (event) {
-            if (event.type === Effect_1.TriggerEventType.EntityCrushed) {
-                var location = material.getItem(event.cardIndex).location;
-                if (location.player === player && !cards.some(function (card) { return card.index === event.cardIndex; })) {
-                    cards.push({ index: event.cardIndex, location: location });
-                }
-            }
-            if (event.type === Effect_1.TriggerEventType.EntityPlaced && event.location.player === player && !cards.some(function (card) { return card.index === event.cardIndex; })) {
-                cards.push({ index: event.cardIndex, location: event.location });
-            }
-        };
-        try {
-            for (var triggerEvents_1 = __values(triggerEvents), triggerEvents_1_1 = triggerEvents_1.next(); !triggerEvents_1_1.done; triggerEvents_1_1 = triggerEvents_1.next()) {
-                var event = triggerEvents_1_1.value;
-                _loop_1(event);
-            }
-        }
-        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 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 _d = cards_1_1.value, index = _d.index, location = _d.location;
-                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffects(index, location, triggerEvent)), false));
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (cards_1_1 && !cards_1_1.done && (_c = cards_1.return)) _c.call(cards_1);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (triggerEvents_2_1 && !triggerEvents_2_1.done && (_b = triggerEvents_2.return)) _b.call(triggerEvents_2);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        return pendingEffects;
-    };
-    TriggerEffectsRule.prototype.triggerCardEffect = function (cardIndex, cardLocation, triggerEvent) {
-        var pendingEffects = this.getCardEffects(cardIndex, cardLocation, triggerEvent);
-        if (pendingEffects.length) {
-            this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
-        }
-    };
-    TriggerEffectsRule.prototype.getCardEffects = function (cardIndex, cardLocation, triggerEvent) {
-        var pendingEffects = [];
-        var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex);
-        for (var effectIndex = 0; effectIndex < (0, EntityDescription_1.getEffects)(card.id.front).length; effectIndex++) {
-            var effect = (0, EntityDescription_1.getEffects)(card.id.front)[effectIndex];
-            if ((0, Effect_1.isTriggeredEffect)(effect) && effect.trigger(triggerEvent, { cardIndex: cardIndex, cardLocation: cardLocation, game: this.game })) {
-                pendingEffects.push({ cardIndex: cardIndex, effectIndex: effectIndex, triggerEvent: triggerEvent, auto: !!effect.auto });
-            }
-        }
-        return pendingEffects;
-    };
-    TriggerEffectsRule.prototype.getPlayersByEffectPriorityOrder = function () {
-        var _a, _b;
-        var firstPlayer = (_b = (_a = this.game.rule) === null || _a === void 0 ? void 0 : _a.player) !== null && _b !== void 0 ? _b : this.material(MaterialType_1.MaterialType.FirstPlayerToken).getItem().location.player;
-        var index = this.game.players.indexOf(firstPlayer);
-        return this.game.players.slice(index).concat(this.game.players.slice(0, index));
-    };
-    return TriggerEffectsRule;
-}(rules_api_1.MaterialRulesPart));
-exports.TriggerEffectsRule = TriggerEffectsRule;
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { isTriggeredEffect, TriggerEventType } from '../../material/entity/Effect';
+import { getEffects } from '../../material/entity/EntityDescription';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+export class TriggerEffectsRule extends MaterialRulesPart {
+    triggerEffects(...triggerEvents) {
+        const players = this.getPlayersByEffectPriorityOrder();
+        for (const player of players.reverse()) {
+            this.triggerPlayerEffects(player, ...triggerEvents);
+        }
+    }
+    triggerPlayerEffects(player, ...triggerEvents) {
+        const pendingEffects = this.getPlayerEffects(player, ...triggerEvents);
+        if (pendingEffects.length) {
+            this.remind(Memory.PendingEffects).unshift(pendingEffects);
+        }
+    }
+    getPlayerEffects(player, ...triggerEvents) {
+        const pendingEffects = [];
+        const pantheon = new Pantheon(this.game, player);
+        const material = this.material(MaterialType.EntityCard);
+        const cards = pantheon.visibleEntities.getIndexes().map((index) => ({ index, location: material.getItem(index).location }));
+        for (const event of triggerEvents) {
+            if (event.type === TriggerEventType.EntityCrushed) {
+                const location = material.getItem(event.cardIndex).location;
+                if (location.player === player && !cards.some((card) => card.index === event.cardIndex)) {
+                    cards.push({ index: event.cardIndex, location });
+                }
+            }
+            if (event.type === TriggerEventType.EntityPlaced && event.location.player === player && !cards.some((card) => card.index === event.cardIndex)) {
+                cards.push({ index: event.cardIndex, location: event.location });
+            }
+        }
+        for (const triggerEvent of triggerEvents) {
+            for (const { index, location } of cards) {
+                pendingEffects.push(...this.getCardEffects(index, location, triggerEvent));
+            }
+        }
+        return pendingEffects;
+    }
+    triggerCardEffect(cardIndex, cardLocation, triggerEvent) {
+        const pendingEffects = this.getCardEffects(cardIndex, cardLocation, triggerEvent);
+        if (pendingEffects.length) {
+            this.remind(Memory.PendingEffects).unshift(pendingEffects);
+        }
+    }
+    getCardEffects(cardIndex, cardLocation, triggerEvent) {
+        const pendingEffects = [];
+        const card = this.material(MaterialType.EntityCard).getItem(cardIndex);
+        for (let effectIndex = 0; effectIndex < getEffects(card.id.front).length; effectIndex++) {
+            const effect = getEffects(card.id.front)[effectIndex];
+            if (isTriggeredEffect(effect) && effect.trigger(triggerEvent, { cardIndex, cardLocation, game: this.game })) {
+                pendingEffects.push({ cardIndex, effectIndex, triggerEvent, auto: !!effect.auto });
+            }
+        }
+        return pendingEffects;
+    }
+    getPlayersByEffectPriorityOrder() {
+        const firstPlayer = this.game.rule?.player ?? this.material(MaterialType.FirstPlayerToken).getItem().location.player;
+        const index = this.game.players.indexOf(firstPlayer);
+        return this.game.players.slice(index).concat(this.game.players.slice(0, index));
+    }
+}

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

@@ -1,14 +1,14 @@
-import { ItemMove } from '@gamepark/rules-api';
-import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
-import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
-import { RuleId } from '../RuleId';
-export declare class UkukuEffectRule extends PlayerEffectRule {
-    ruleId: RuleId;
-    getPlayerMoves(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
-    afterItemMove(move: ItemMove): import("@gamepark/rules-api").StartRule<RuleId.UkukuPlaceEffect>[];
-}
-export declare class UkukuPlaceEffectRule extends PlaceCardEffectRule {
-    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
-    getAvailableDestinations(cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
-    onRuleEnd(): never[];
-}
+import { ItemMove } from '@gamepark/rules-api';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { RuleId } from '../RuleId';
+export declare class UkukuEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").StartRule<RuleId.UkukuPlaceEffect>[];
+}
+export declare class UkukuPlaceEffectRule extends PlaceCardEffectRule {
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableDestinations(cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
+    onRuleEnd(): never[];
+}

package/dist/rules/effects/UkukuEffectRule.js

@@ -1,66 +1,35 @@
-"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.UkukuPlaceEffectRule = exports.UkukuEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var Destiny_1 = require("../../material/Destiny");
-var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
-var PlayerEffectRule_1 = require("../../material/entity/PlayerEffectRule");
-var LocationType_1 = require("../../material/LocationType");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var UkukuEffectRule = (function (_super) {
-    __extends(UkukuEffectRule, _super);
-    function UkukuEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.UkukuEffect;
-        return _this;
-    }
-    UkukuEffectRule.prototype.getPlayerMoves = function () {
-        return new Destiny_1.Destiny(this.game).creaturesOnTopOfDecks.moveItems({ type: LocationType_1.LocationType.PlayerSelectedCards, player: this.player });
-    };
-    UkukuEffectRule.prototype.afterItemMove = function (move) {
-        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.PlayerSelectedCards) {
-            this.memorize(Memory_1.Memory.TargetEntities, move.itemIndex);
-            return [this.startRule(RuleId_1.RuleId.UkukuPlaceEffect)];
-        }
-        return [];
-    };
-    return UkukuEffectRule;
-}(PlayerEffectRule_1.PlayerEffectRule));
-exports.UkukuEffectRule = UkukuEffectRule;
-var UkukuPlaceEffectRule = (function (_super) {
-    __extends(UkukuPlaceEffectRule, _super);
-    function UkukuPlaceEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    UkukuPlaceEffectRule.prototype.getCardsToPlace = function () {
-        return this.material(MaterialType_1.MaterialType.EntityCard).index(this.remind(Memory_1.Memory.TargetEntities));
-    };
-    UkukuPlaceEffectRule.prototype.getAvailableDestinations = function (cardIndex) {
-        var ukuku = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex);
-        return new Pantheon_1.Pantheon(this.game, this.player).legalSpaces.filter(function (space) { return space.x === ukuku.location.x; });
-    };
-    UkukuPlaceEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.TargetEntities);
-        return [];
-    };
-    return UkukuPlaceEffectRule;
-}(PlaceCardEffectRule_1.PlaceCardEffectRule));
-exports.UkukuPlaceEffectRule = UkukuPlaceEffectRule;
+import { isMoveItemType } from '@gamepark/rules-api';
+import { Destiny } from '../../material/Destiny';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { LocationType } from '../../material/LocationType';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class UkukuEffectRule extends PlayerEffectRule {
+    ruleId = RuleId.UkukuEffect;
+    getPlayerMoves() {
+        return new Destiny(this.game).creaturesOnTopOfDecks.moveItems({ type: LocationType.PlayerSelectedCards, player: this.player });
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerSelectedCards) {
+            this.memorize(Memory.TargetEntities, move.itemIndex);
+            return [this.startRule(RuleId.UkukuPlaceEffect)];
+        }
+        return [];
+    }
+}
+export class UkukuPlaceEffectRule extends PlaceCardEffectRule {
+    getCardsToPlace() {
+        return this.material(MaterialType.EntityCard).index(this.remind(Memory.TargetEntities));
+    }
+    getAvailableDestinations(cardIndex) {
+        const ukuku = this.material(MaterialType.EntityCard).getItem(cardIndex);
+        return new Pantheon(this.game, this.player).legalSpaces.filter((space) => space.x === ukuku.location.x);
+    }
+    onRuleEnd() {
+        this.forget(Memory.TargetEntities);
+        return [];
+    }
+}

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

@@ -1,12 +1,12 @@
-import { MaterialItem, MaterialMove } from '@gamepark/rules-api';
-import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
-import { RuleId } from '../RuleId';
-export declare class VetalaEffectRule extends MoveEffectRule {
-    ruleId: RuleId;
-    onRuleStart(): MaterialMove[];
-    getPlayerMoves(): MaterialMove<number, number, number, number>[];
-    getAvailableDestinations(card: MaterialItem, cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
-    onCardMoved(): import("@gamepark/rules-api").CustomMove<number>[];
-    onCardSacrificed(): import("@gamepark/rules-api").CustomMove<number>[];
-    onRuleEnd(): never[];
-}
+import { MaterialItem, MaterialMove } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { RuleId } from '../RuleId';
+export declare class VetalaEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    getAvailableDestinations(card: MaterialItem, cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
+    onCardMoved(): import("@gamepark/rules-api").CustomMove[];
+    onCardSacrificed(): import("@gamepark/rules-api").CustomMove[];
+    onRuleEnd(): never[];
+}

package/dist/rules/effects/VetalaEffectRule.js

@@ -1,62 +1,37 @@
-"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.VetalaEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
-var LocationType_1 = require("../../material/LocationType");
-var MaterialType_1 = require("../../material/MaterialType");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var VetalaEffectRule = (function (_super) {
-    __extends(VetalaEffectRule, _super);
-    function VetalaEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.VetalaEffect;
-        return _this;
-    }
-    VetalaEffectRule.prototype.onRuleStart = function () {
-        var entitiesSacrificed = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerDiscard).player(this.player).length;
-        if (entitiesSacrificed) {
-            this.memorize(Memory_1.Memory.EffectCount, entitiesSacrificed);
-            return [];
-        }
-        else {
-            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-        }
-    };
-    VetalaEffectRule.prototype.getPlayerMoves = function () {
-        return _super.prototype.getPlayerMoves.call(this).concat(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-    };
-    VetalaEffectRule.prototype.getAvailableDestinations = function (card, cardIndex) {
-        return _super.prototype.getAvailableDestinations.call(this, card, cardIndex).filter(function (space) { return (0, rules_api_1.areAdjacentSquares)(card.location, space); });
-    };
-    VetalaEffectRule.prototype.onCardMoved = function () {
-        var count = this.memorize(Memory_1.Memory.EffectCount, function (count) { return count - 1; });
-        return count > 0 ? [] : [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-    };
-    VetalaEffectRule.prototype.onCardSacrificed = function () {
-        return this.onCardMoved();
-    };
-    VetalaEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.EffectCount);
-        return [];
-    };
-    return VetalaEffectRule;
-}(MoveEffectRule_1.MoveEffectRule));
-exports.VetalaEffectRule = VetalaEffectRule;
+import { areAdjacentSquares } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { LocationType } from '../../material/LocationType';
+import { MaterialType } from '../../material/MaterialType';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class VetalaEffectRule extends MoveEffectRule {
+    ruleId = RuleId.VetalaEffect;
+    onRuleStart() {
+        const entitiesSacrificed = this.material(MaterialType.EntityCard).location(LocationType.PlayerDiscard).player(this.player).length;
+        if (entitiesSacrificed) {
+            this.memorize(Memory.EffectCount, entitiesSacrificed);
+            return [];
+        }
+        else {
+            return [this.customMove(CustomMoveType.EndEffect)];
+        }
+    }
+    getPlayerMoves() {
+        return super.getPlayerMoves().concat(this.customMove(CustomMoveType.EndEffect));
+    }
+    getAvailableDestinations(card, cardIndex) {
+        return super.getAvailableDestinations(card, cardIndex).filter((space) => areAdjacentSquares(card.location, space));
+    }
+    onCardMoved() {
+        const count = this.memorize(Memory.EffectCount, (count) => count - 1);
+        return count > 0 ? [] : [this.customMove(CustomMoveType.EndEffect)];
+    }
+    onCardSacrificed() {
+        return this.onCardMoved();
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

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

@@ -1,7 +1,7 @@
-import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
-import { RuleId } from '../RuleId';
-export declare class ViracochaEffectRule extends SacrificeEffectRule {
-    ruleId: RuleId;
-    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(): (import("@gamepark/rules-api").CustomMove<number> | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
-}
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class ViracochaEffectRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+}

package/dist/rules/effects/ViracochaEffectRule.js

@@ -1,40 +1,15 @@
-"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.ViracochaEffectRule = void 0;
-var CustomMoveType_1 = require("../../CustomMoveType");
-var Entity_1 = require("../../material/Entity");
-var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
-var Pantheon_1 = require("../../material/Pantheon");
-var RuleId_1 = require("../RuleId");
-var ViracochaEffectRule = (function (_super) {
-    __extends(ViracochaEffectRule, _super);
-    function ViracochaEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.ViracochaEffect;
-        return _this;
-    }
-    ViracochaEffectRule.prototype.getCardsToSacrifice = function () {
-        return _super.prototype.getCardsToSacrifice.call(this).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
-    };
-    ViracochaEffectRule.prototype.onSacrifice = function () {
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        return [pantheon.gainFavor(2), this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-    };
-    return ViracochaEffectRule;
-}(SacrificeEffectRule_1.SacrificeEffectRule));
-exports.ViracochaEffectRule = ViracochaEffectRule;
+import { CustomMoveType } from '../../CustomMoveType';
+import { isCreature } from '../../material/Entity';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { Pantheon } from '../../material/Pantheon';
+import { RuleId } from '../RuleId';
+export class ViracochaEffectRule extends SacrificeEffectRule {
+    ruleId = RuleId.ViracochaEffect;
+    getCardsToSacrifice() {
+        return super.getCardsToSacrifice().id((id) => isCreature(id.front));
+    }
+    onSacrifice() {
+        const pantheon = new Pantheon(this.game, this.player);
+        return [pantheon.gainFavor(2), this.customMove(CustomMoveType.EndEffect)];
+    }
+}

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

@@ -1,8 +1,8 @@
-import { ItemMove } from '@gamepark/rules-api';
-import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
-import { RuleId } from '../RuleId';
-export declare class WerehyenaEffectRule extends PlayerEffectRule {
-    ruleId: RuleId;
-    getPlayerMoves(): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
-    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
-}
+import { ItemMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { RuleId } from '../RuleId';
+export declare class WerehyenaEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): import("@gamepark/rules-api").MaterialMove[];
+    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+}