@gamepark/mythologies 0.10.0 → 0.12.0

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

@@ -1,13 +1,13 @@
-import { MaterialMove, XYCoordinates } from '@gamepark/rules-api';
-import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
-import { PlayerColor } from '../../PlayerColor';
-import { RuleId } from '../RuleId';
-export declare class RakshasaEffectRule extends PlaceCardEffectRule {
-    ruleId: RuleId;
-    canPlayEffect(cardIndex: number): boolean;
-    onRuleStart(): MaterialMove[];
-    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
-    getAvailableDestinations(cardIndex: number): (XYCoordinates & {
-        player: PlayerColor;
-    })[];
-}
+import { MaterialMove, XYCoordinates } from '@gamepark/rules-api';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class RakshasaEffectRule extends PlaceCardEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    onRuleStart(): MaterialMove[];
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableDestinations(cardIndex: number): (XYCoordinates & {
+        player: PlayerColor;
+    })[];
+}

package/dist/rules/effects/RakshasaEffectRule.js

@@ -1,48 +1,23 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RakshasaEffectRule = void 0;
-var Destiny_1 = require("../../material/Destiny");
-var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var RuleId_1 = require("../RuleId");
-var RakshasaEffectRule = (function (_super) {
-    __extends(RakshasaEffectRule, _super);
-    function RakshasaEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.RakshasaEffect;
-        return _this;
-    }
-    RakshasaEffectRule.prototype.canPlayEffect = function (cardIndex) {
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        return pantheon.gems > 0 && _super.prototype.canPlayEffect.call(this, cardIndex);
-    };
-    RakshasaEffectRule.prototype.onRuleStart = function () {
-        return [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
-    };
-    RakshasaEffectRule.prototype.getCardsToPlace = function () {
-        return new Destiny_1.Destiny(this.game).getAvailableCards(this.player);
-    };
-    RakshasaEffectRule.prototype.getAvailableDestinations = function (cardIndex) {
-        var location = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location;
-        var pantheon = new Pantheon_1.Pantheon(this.game, location.player);
-        return pantheon.isLegalSpaceToInvoke(location) ? [location] : [];
-    };
-    return RakshasaEffectRule;
-}(PlaceCardEffectRule_1.PlaceCardEffectRule));
-exports.RakshasaEffectRule = RakshasaEffectRule;
+import { Destiny } from '../../material/Destiny';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { RuleId } from '../RuleId';
+export class RakshasaEffectRule extends PlaceCardEffectRule {
+    ruleId = RuleId.RakshasaEffect;
+    canPlayEffect(cardIndex) {
+        const pantheon = new Pantheon(this.game, this.player);
+        return pantheon.gems > 0 && super.canPlayEffect(cardIndex);
+    }
+    onRuleStart() {
+        return [new Pantheon(this.game, this.player).spendGems(1)];
+    }
+    getCardsToPlace() {
+        return new Destiny(this.game).getAvailableCards(this.player);
+    }
+    getAvailableDestinations(cardIndex) {
+        const location = this.material(MaterialType.EntityCard).getItem(cardIndex).location;
+        const pantheon = new Pantheon(this.game, location.player);
+        return pantheon.isLegalSpaceToInvoke(location) ? [location] : [];
+    }
+}

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

@@ -1,12 +1,15 @@
-import { CustomMove, MaterialMove, PlayerTurnRule, RuleMove, RuleStep } from '@gamepark/rules-api';
-import { PendingEffect } from '../../material/entity/Effect';
-import { RuleId } from '../RuleId';
-export declare class ResolveEffectsRule extends PlayerTurnRule {
-    startEffectsResolution(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.ResolveEffects>[] | import("@gamepark/rules-api").StartRule<RuleId.ResolveEffects>[];
-    onRuleStart(_move: RuleMove, previousRule: RuleStep): CustomMove<number>[];
-    getPlayerMoves(): CustomMove<number>[];
-    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
-    onPlayEffect(pendingEffect: PendingEffect): MaterialMove<number, number, number, number>[];
-    playEffect(pendingEffect: PendingEffect): MaterialMove<number, number, number, number>[];
-    onEndEffect(): MaterialMove<number, number, number, number>[];
-}
+import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule, RuleMove, RuleStep } from '@gamepark/rules-api';
+import { CardEffect, PlayerPendingEffects } from '../../material/entity/Effect';
+import { RuleId } from '../RuleId';
+export declare class ResolveEffectsRule extends PlayerTurnRule {
+    startEffectsResolution(): import("@gamepark/rules-api").StartRule<RuleId.ResolveEffects>[] | import("@gamepark/rules-api").StartPlayerTurn<import("../../PlayerColor").PlayerColor, RuleId.ResolveEffects>[];
+    isAutoEffects(): boolean;
+    onRuleStart(_move: RuleMove, previousRule: RuleStep): MaterialMove[];
+    getPendingEffects(): PlayerPendingEffects;
+    getPlayerMoves(): CustomMove[] | import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    beforeItemMove(move: ItemMove): CustomMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    onPlayEffect(effect: CardEffect): MaterialMove[];
+    playEffect(cardEffect: CardEffect): MaterialMove[];
+    onEndEffect(): MaterialMove[];
+}

package/dist/rules/effects/ResolveEffectsRule.js

@@ -1,141 +1,154 @@
-"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.ResolveEffectsRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var lodash_1 = require("lodash");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var Effect_1 = require("../../material/entity/Effect");
-var EntityDescription_1 = require("../../material/entity/EntityDescription");
-var MaterialType_1 = require("../../material/MaterialType");
-var Memory_1 = require("../../Memory");
-var EndGameRule_1 = require("../EndGameRule");
-var RuleId_1 = require("../RuleId");
-var ResolveEffectsRule = (function (_super) {
-    __extends(ResolveEffectsRule, _super);
-    function ResolveEffectsRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ResolveEffectsRule.prototype.startEffectsResolution = function () {
-        var pendingEffects = this.remind(Memory_1.Memory.PendingEffects)[0];
-        if (pendingEffects.every(function (effect) { return effect.auto; })) {
-            return [this.startRule(RuleId_1.RuleId.ResolveEffects)];
-        }
-        var cardIndex = pendingEffects[0].cardIndex;
-        var player = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location.player;
-        return [this.startPlayerTurn(RuleId_1.RuleId.ResolveEffects, player)];
-    };
-    ResolveEffectsRule.prototype.onRuleStart = function (_move, previousRule) {
-        if (!this.remind(Memory_1.Memory.PendingRule)) {
-            this.memorize(Memory_1.Memory.PendingRule, previousRule);
-        }
-        var moves = this.getPlayerMoves();
-        return moves.length === 1 ? moves : [];
-    };
-    ResolveEffectsRule.prototype.getPlayerMoves = function () {
-        var _this = this;
-        var _a;
-        var pendingEffects = (_a = this.remind(Memory_1.Memory.PendingEffects)[0]) !== null && _a !== void 0 ? _a : [];
-        var autoEffect = pendingEffects.find(function (effect) { return effect.auto; });
-        if (autoEffect) {
-            return [this.customMove(CustomMoveType_1.CustomMoveType.PlayEffect, autoEffect)];
-        }
-        return pendingEffects.map(function (effect) { return _this.customMove(CustomMoveType_1.CustomMoveType.PlayEffect, effect); });
-    };
-    ResolveEffectsRule.prototype.onCustomMove = function (move) {
-        if (move.type === CustomMoveType_1.CustomMoveType.PlayEffect) {
-            return this.onPlayEffect(move.data);
-        }
-        else if (move.type === CustomMoveType_1.CustomMoveType.EndEffect) {
-            return this.onEndEffect();
-        }
-        return [];
-    };
-    ResolveEffectsRule.prototype.onPlayEffect = function (pendingEffect) {
-        var pendingEffects = this.remind(Memory_1.Memory.PendingEffects);
-        if (pendingEffects.length) {
-            pendingEffects[0] = pendingEffects[0].filter(function (effect) { return !(0, lodash_1.isEqual)(effect, pendingEffect); });
-            if (pendingEffects[0].length === 0) {
-                pendingEffects.splice(0, 1);
-            }
-        }
-        return this.playEffect(pendingEffect);
-    };
-    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 = (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 = []; }
-                return indexes.concat(pendingEffect.cardIndex);
-            });
-        }
-        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));
-        }
-        return moves;
-    };
-    ResolveEffectsRule.prototype.onEndEffect = function () {
-        var moves = [];
-        this.forget(Memory_1.Memory.OngoingEffect);
-        if (this.remind(Memory_1.Memory.PendingEffects).length) {
-            moves.push.apply(moves, __spreadArray([], __read(this.startEffectsResolution()), false));
-        }
-        else {
-            var pendingRule = this.remind(Memory_1.Memory.PendingRule);
-            if (pendingRule) {
-                this.forget(Memory_1.Memory.PendingRule);
-                if (pendingRule.id === RuleId_1.RuleId.EndGame) {
-                    moves.push.apply(moves, __spreadArray(__spreadArray([], __read(new EndGameRule_1.EndGameRule(this.game).convertGems()), false), [this.endGame()], false));
-                }
-                else {
-                    moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlaceCards, pendingRule.player));
-                }
-            }
-        }
-        return moves;
-    };
-    return ResolveEffectsRule;
-}(rules_api_1.PlayerTurnRule));
-exports.ResolveEffectsRule = ResolveEffectsRule;
+import { isMoveItem, MoveKind, PlayerTurnRule } from '@gamepark/rules-api';
+import { isEqual } from 'es-toolkit';
+import { CustomMoveType } from '../../CustomMoveType';
+import { oncePerTurn, PendingEffectsType } from '../../material/entity/Effect';
+import { getEffects } from '../../material/entity/EntityDescription';
+import { LocationType } from '../../material/LocationType';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { Memory } from '../../Memory';
+import { EndGameRule } from '../EndGameRule';
+import { RuleId } from '../RuleId';
+export class ResolveEffectsRule extends PlayerTurnRule {
+    startEffectsResolution() {
+        const pendingEffects = this.getPendingEffects();
+        if (this.isAutoEffects()) {
+            return [this.startRule(RuleId.ResolveEffects)];
+        }
+        return [this.startPlayerTurn(RuleId.ResolveEffects, pendingEffects.player)];
+    }
+    isAutoEffects() {
+        const pendingEffects = this.getPendingEffects();
+        switch (pendingEffects.type) {
+            case PendingEffectsType.CardsEffects:
+                return pendingEffects.effects.every((effect) => effect.auto);
+            case PendingEffectsType.InvokeGain:
+                return true;
+            case PendingEffectsType.BonusGains:
+                return pendingEffects.columns.length + pendingEffects.lines.length === 1;
+        }
+    }
+    onRuleStart(_move, previousRule) {
+        if (!this.remind(Memory.PendingRule)) {
+            this.memorize(Memory.PendingRule, previousRule);
+        }
+        const pendingEffects = this.getPendingEffects();
+        if (pendingEffects.type === PendingEffectsType.InvokeGain) {
+            return [...new Pantheon(this.game, this.player).getInvokeGains(pendingEffects.entity, pendingEffects.line), this.customMove(CustomMoveType.EndEffect)];
+        }
+        const moves = this.getPlayerMoves();
+        if (moves.length === 1) {
+            return moves;
+        }
+        else if (moves.length === 0) {
+            return [this.customMove(CustomMoveType.EndEffect)];
+        }
+        return [];
+    }
+    getPendingEffects() {
+        return this.remind(Memory.PendingEffects)[0];
+    }
+    getPlayerMoves() {
+        const pendingEffects = this.getPendingEffects();
+        if (!pendingEffects)
+            return [];
+        if (pendingEffects.type === PendingEffectsType.CardsEffects) {
+            const autoEffect = pendingEffects.effects.find((effect) => effect.auto);
+            if (autoEffect) {
+                return [this.customMove(CustomMoveType.PlayEffect, autoEffect)];
+            }
+            return pendingEffects.effects.map((effect) => this.customMove(CustomMoveType.PlayEffect, effect));
+        }
+        else if (pendingEffects.type === PendingEffectsType.BonusGains) {
+            return [
+                ...this.material(MaterialType.GemToken)
+                    .location(LocationType.PantheonLineBonus)
+                    .player(this.player)
+                    .location((l) => pendingEffects.lines.includes(l.y))
+                    .moveItems({ type: LocationType.PlayerGems, player: this.player }),
+                ...this.material(MaterialType.FavorToken)
+                    .location(LocationType.PantheonColumnBonus)
+                    .player(this.player)
+                    .location((l) => pendingEffects.columns.includes(l.x))
+                    .moveItems({ type: LocationType.PlayerFavor, player: this.player })
+            ];
+        }
+        return [];
+    }
+    beforeItemMove(move) {
+        const pendingEffects = this.getPendingEffects();
+        if (isMoveItem(move) &&
+            (move.itemType === MaterialType.GemToken || move.itemType === MaterialType.FavorToken) &&
+            pendingEffects.type === PendingEffectsType.BonusGains) {
+            const item = this.material(move.itemType).getItem(move.itemIndex);
+            if (item.location.type === LocationType.PantheonColumnBonus) {
+                pendingEffects.columns = pendingEffects.columns.filter((column) => column !== item.location.x);
+            }
+            else if (item.location.type === LocationType.PantheonLineBonus) {
+                pendingEffects.lines = pendingEffects.lines.filter((line) => line !== item.location.y);
+            }
+            if (this.getPlayerMoves().length === 0) {
+                return [this.customMove(CustomMoveType.EndEffect)];
+            }
+        }
+        return [];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.PlayEffect) {
+            return this.onPlayEffect(move.data);
+        }
+        else if (move.type === CustomMoveType.EndEffect) {
+            return this.onEndEffect();
+        }
+        return [];
+    }
+    onPlayEffect(effect) {
+        const pendingEffects = this.getPendingEffects();
+        const index = pendingEffects.effects.findIndex((e) => isEqual(e, effect));
+        if (index !== -1) {
+            pendingEffects.effects.splice(index, 1);
+            if (!pendingEffects.effects.length) {
+                this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
+            }
+        }
+        return this.playEffect(effect);
+    }
+    playEffect(cardEffect) {
+        this.memorize(Memory.OngoingEffect, cardEffect);
+        const card = this.material(MaterialType.EntityCard).getItem(cardEffect.cardIndex);
+        const effect = getEffects(card.id.front)[cardEffect.effectIndex];
+        if (effect.trigger === oncePerTurn) {
+            this.memorize(Memory.OncePerTurn, (indexes = []) => indexes.concat(cardEffect.cardIndex));
+        }
+        const moves = new effect.rule(this.game).playEffect();
+        if (!moves.some((move) => move.kind === MoveKind.RulesMove)) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    onEndEffect() {
+        const moves = [];
+        if (this.remind(Memory.OngoingEffect) !== undefined) {
+            this.forget(Memory.OngoingEffect);
+        }
+        else {
+            this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
+        }
+        if (this.remind(Memory.PendingEffects).length) {
+            moves.push(...this.startEffectsResolution());
+        }
+        else {
+            const pendingRule = this.remind(Memory.PendingRule);
+            if (pendingRule) {
+                this.forget(Memory.PendingRule);
+                if (pendingRule.id === RuleId.EndGame) {
+                    moves.push(...new EndGameRule(this.game).convertGems(), this.endGame());
+                }
+                else {
+                    moves.push(this.startPlayerTurn(RuleId.PlaceCards, pendingRule.player));
+                }
+            }
+        }
+        return moves;
+    }
+}

package/dist/rules/effects/SelkieEffectRule.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 SelkieEffectRule extends PlayerEffectRule {
-    ruleId: RuleId;
-    getPlayerMoves(): import("@gamepark/rules-api").CreateItem<number, number, number>[];
-    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove<number>[];
-}
+import { ItemMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { RuleId } from '../RuleId';
+export declare class SelkieEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): import("@gamepark/rules-api").CreateItem<number, number, number>[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove[];
+}

package/dist/rules/effects/SelkieEffectRule.js

@@ -1,44 +1,19 @@
-"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.SelkieEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var PlayerEffectRule_1 = require("../../material/entity/PlayerEffectRule");
-var MaterialType_1 = require("../../material/MaterialType");
-var Pantheon_1 = require("../../material/Pantheon");
-var RuleId_1 = require("../RuleId");
-var SelkieEffectRule = (function (_super) {
-    __extends(SelkieEffectRule, _super);
-    function SelkieEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.ruleId = RuleId_1.RuleId.SelkieEffect;
-        return _this;
-    }
-    SelkieEffectRule.prototype.getPlayerMoves = function () {
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        return [pantheon.gainFavor(1), pantheon.gainGems(1)];
-    };
-    SelkieEffectRule.prototype.afterItemMove = function (move) {
-        if ((0, rules_api_1.isCreateItemType)(MaterialType_1.MaterialType.GemToken)(move) || (0, rules_api_1.isCreateItemType)(MaterialType_1.MaterialType.FavorToken)(move)) {
-            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-        }
-        return [];
-    };
-    return SelkieEffectRule;
-}(PlayerEffectRule_1.PlayerEffectRule));
-exports.SelkieEffectRule = SelkieEffectRule;
+import { isCreateItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { MaterialType } from '../../material/MaterialType';
+import { Pantheon } from '../../material/Pantheon';
+import { RuleId } from '../RuleId';
+export class SelkieEffectRule extends PlayerEffectRule {
+    ruleId = RuleId.SelkieEffect;
+    getPlayerMoves() {
+        const pantheon = new Pantheon(this.game, this.player);
+        return [pantheon.gainFavor(1), pantheon.gainGems(1)];
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.GemToken)(move) || isCreateItemType(MaterialType.FavorToken)(move)) {
+            return [this.customMove(CustomMoveType.EndEffect)];
+        }
+        return [];
+    }
+}

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

@@ -1,10 +1,10 @@
-import { ItemMove, MaterialMove } from '@gamepark/rules-api';
-import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
-import { RuleId } from '../RuleId';
-export declare class ShivaEffectRule extends PlayerEffectRule {
-    ruleId: RuleId;
-    canPlayEffect(cardIndex: number): boolean;
-    onRuleStart(): MaterialMove[];
-    getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MoveItemsAtOnce<number, number, number>[];
-    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CustomMove<number> | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
-}
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { RuleId } from '../RuleId';
+export declare class ShivaEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MoveItemsAtOnce<number, number, number>[];
+    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+}