@gamepark/mythologies 0.10.0 → 0.12.0

package/dist/rules/effects/TianlongEffectRule.js

@@ -1,105 +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 __());
-    };
-})();
-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.TianlongOpponentsEffectRule = exports.TianlongEffectRule = void 0;
-var CustomMoveType_1 = require("../../CustomMoveType");
-var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
-var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var Memory_1 = require("../../Memory");
-var RuleId_1 = require("../RuleId");
-var TianlongEffectRule = (function (_super) {
-    __extends(TianlongEffectRule, _super);
-    function TianlongEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.TianlongEffect;
-        return _this;
-    }
-    TianlongEffectRule.prototype.getPlayerMoves = function () {
-        var moves = [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-        if (new Pantheon_1.Pantheon(this.game, this.player).gems > 0) {
-            moves.push.apply(moves, __spreadArray([], __read(_super.prototype.getPlayerMoves.call(this)), false));
-        }
-        return moves;
-    };
-    TianlongEffectRule.prototype.onCardMoved = function (move) {
-        if (move.location.player === this.player) {
-            var _a = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).location, x = _a.x, y = _a.y;
-            this.memorize(Memory_1.Memory.TargetLocations, [
-                { x: x, y: y },
-                { x: move.location.x, y: move.location.y }
-            ]);
-            var opponentsEffectRule = new TianlongOpponentsEffectRule(this.game);
-            return __spreadArray([new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)], __read(opponentsEffectRule.playEffect()), false);
-        }
-        return [];
-    };
-    return TianlongEffectRule;
-}(MoveEffectRule_1.MoveEffectRule));
-exports.TianlongEffectRule = TianlongEffectRule;
-var TianlongOpponentsEffectRule = (function (_super) {
-    __extends(TianlongOpponentsEffectRule, _super);
-    function TianlongOpponentsEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.TianlongOpponentsEffect;
-        return _this;
-    }
-    TianlongOpponentsEffectRule.prototype.getAffectedPlayers = function () {
-        var _this = this;
-        return this.game.players.filter(function (player) { return _this.isOpponent(player); });
-    };
-    TianlongOpponentsEffectRule.prototype.getMovingCards = function (player) {
-        var _a = this.remind(Memory_1.Memory.TargetLocations)[0], x = _a.x, y = _a.y;
-        return _super.prototype.getMovingCards.call(this, player).location(function (l) { return l.x === x && l.y === y; });
-    };
-    TianlongOpponentsEffectRule.prototype.isLegalDestination = function (space) {
-        var _a = this.remind(Memory_1.Memory.TargetLocations)[1], x = _a.x, y = _a.y;
-        return space.x === x && space.y === y;
-    };
-    TianlongOpponentsEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.TargetLocations);
-        return [];
-    };
-    return TianlongOpponentsEffectRule;
-}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
-exports.TianlongOpponentsEffectRule = TianlongOpponentsEffectRule;
+import { CustomMoveType } from '../../CustomMoveType';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { RuleId } from '../RuleId';
+export class TianlongEffectRule extends MoveEffectRule {
+    ruleId = RuleId.TianlongEffect;
+    getPlayerMoves() {
+        const moves = [this.customMove(CustomMoveType.EndEffect)];
+        if (new Pantheon(this.game, this.player).gems > 0) {
+            moves.push(...super.getPlayerMoves());
+        }
+        return moves;
+    }
+    onCardMoved(move) {
+        if (move.location.player === this.player) {
+            const { x, y } = this.material(MaterialType.EntityCard).getItem(move.itemIndex).location;
+            this.memorize(Memory.TargetLocations, [
+                { x, y },
+                { x: move.location.x, y: move.location.y }
+            ]);
+            const opponentsEffectRule = new TianlongOpponentsEffectRule(this.game);
+            return [new Pantheon(this.game, this.player).spendGems(1), ...opponentsEffectRule.playEffect()];
+        }
+        return [];
+    }
+}
+export class TianlongOpponentsEffectRule extends SimultaneousMoveEffectRule {
+    ruleId = RuleId.TianlongOpponentsEffect;
+    getAffectedPlayers() {
+        return this.game.players.filter((player) => this.isOpponent(player));
+    }
+    getMovingCards(player) {
+        const { x, y } = this.remind(Memory.TargetLocations)[0];
+        return super.getMovingCards(player).location((l) => l.x === x && l.y === y);
+    }
+    isLegalDestination(space) {
+        const { x, y } = this.remind(Memory.TargetLocations)[1];
+        return space.x === x && space.y === y;
+    }
+    onRuleEnd() {
+        this.forget(Memory.TargetLocations);
+        return [];
+    }
+}

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

@@ -1,11 +1,12 @@
-import { Location, MaterialRulesPart } from '@gamepark/rules-api';
-import { PendingEffect, TriggerEvent } from '../../material/entity/Effect';
-import { PlayerColor } from '../../PlayerColor';
-export declare class TriggerEffectsRule extends MaterialRulesPart {
-    triggerEffects(...triggerEvents: TriggerEvent[]): void;
-    triggerPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): void;
-    getPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): PendingEffect<TriggerEvent>[];
-    triggerCardEffect(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent): void;
-    getCardEffects(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent): PendingEffect[];
-    private getPlayersByEffectPriorityOrder;
-}
+import { Location, MaterialRulesPart } from '@gamepark/rules-api';
+import { Entity } from '../../material/Entity';
+import { CardEffect, TriggerEvent } from '../../material/entity/Effect';
+import { PlayerColor } from '../../PlayerColor';
+export declare class TriggerEffectsRule extends MaterialRulesPart {
+    triggerEffects(...triggerEvents: TriggerEvent[]): void;
+    triggerPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): void;
+    getPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): CardEffect[];
+    triggerCardEffect(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent, entity?: Entity): void;
+    getCardEffects(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent, entity?: Entity): CardEffect[];
+    getPlayersByEffectPriorityOrder(): PlayerColor[];
+}

package/dist/rules/effects/TriggerEffectsRule.js

@@ -1,183 +1,67 @@
-"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, PendingEffectsType, 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 effects = this.getPlayerEffects(player, ...triggerEvents);
+        if (effects.length) {
+            this.remind(Memory.PendingEffects).unshift({ type: PendingEffectsType.CardsEffects, player, effects });
+        }
+    }
+    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, entity) {
+        const effects = this.getCardEffects(cardIndex, cardLocation, triggerEvent, entity);
+        if (effects.length) {
+            this.remind(Memory.PendingEffects).unshift({ type: PendingEffectsType.CardsEffects, player: cardLocation.player, effects });
+        }
+    }
+    getCardEffects(cardIndex, cardLocation, triggerEvent, entity = this.material(MaterialType.EntityCard).getItem(cardIndex).id.front) {
+        const pendingEffects = [];
+        const effects = getEffects(entity);
+        for (let effectIndex = 0; effectIndex < effects.length; effectIndex++) {
+            const effect = effects[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.remind(Memory.PendingRule)?.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[];
+}