@gamepark/mythologies 1.0.11 → 1.0.13

package/dist/MythologiesRules.js

@@ -1,4 +1,4 @@
-import { FillGapStrategy, hideFront, hideFrontToOthers, hideItemId, isMoveItemType, isMoveItemTypeAtOnce, PositiveSequenceStrategy, SecretMaterialRules, StackingStrategy } from '@gamepark/rules-api';
+import { FillGapStrategy, hideFront, hideFrontToOthers, hideItemId, isMoveItemType, PositiveSequenceStrategy, SecretMaterialRules, StackingStrategy } from '@gamepark/rules-api';
 import { Destiny } from './material/Destiny';
 import { isGod } from './material/Entity';
 import { LineEventType, TriggerEventType } from './material/entity/Effect';
@@ -177,7 +177,7 @@ export class MythologiesRules extends SecretMaterialRules {
             if (gem.type === LocationType.PantheonLineBonus && player === move.location.player) {
                 const firstEffect = this.remind(Memory.PendingEffects)[0];
                 new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.LineEvent, eventType: LineEventType.BonusGain, player, y: gem.y });
-                if (this.remind(Memory.PendingEffects)[0] !== firstEffect) {
+                if (this.remind(Memory.PendingEffects)[0] !== firstEffect && this.game.rule?.id !== RuleId.ResolveEffects) {
                     consequences.push(...new ResolveEffectsRule(this.game).startEffectsResolution());
                 }
             }
@@ -188,23 +188,11 @@ export class MythologiesRules extends SecretMaterialRules {
             if (favor.type === LocationType.PantheonColumnBonus && player === move.location.player) {
                 const firstEffect = this.remind(Memory.PendingEffects)[0];
                 new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.ColumnEvent, eventType: LineEventType.BonusGain, player, x: favor.x });
-                if (this.remind(Memory.PendingEffects)[0] !== firstEffect) {
+                if (this.remind(Memory.PendingEffects)[0] !== firstEffect && this.game.rule?.id !== RuleId.ResolveEffects) {
                     consequences.push(...new ResolveEffectsRule(this.game).startEffectsResolution());
                 }
             }
         }
-        if (isMoveItemType(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
-            const card = this.material(MaterialType.EntityCard).getItem(move.itemIndex);
-            if (card.location.type === LocationType.Pantheon) {
-                new Pantheon(this.game, card.location.player).onEntitySacrificed(move.itemIndex);
-            }
-        }
-        if (isMoveItemTypeAtOnce(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
-            const firstCard = this.material(MaterialType.EntityCard).getItem(move.indexes[0]);
-            if (firstCard.location.type === LocationType.Pantheon) {
-                new Pantheon(this.game, firstCard.location.player).onPileSacrificed(move.indexes);
-            }
-        }
         return consequences;
     }
     getAutomaticMoves() {

package/dist/material/Pantheon.d.ts

@@ -42,7 +42,7 @@ export declare class Pantheon extends MaterialRulesPart {
     isVisible(entity: EntityItem): boolean;
     get mythologies(): import("./Mythology").Mythology[];
     get missingMythologies(): import("./Mythology").Mythology[];
-    onEntitySacrificed(cardIndex: number): void;
+    onCardSacrificed(cardIndex: number, updateGrid?: boolean): void;
     onPileSacrificed(indexes: number[]): void;
     isOpponentOngoingEffect(): boolean;
     replaceSacrifice(cards: EntityItem[]): Material<number, number, number>;

package/dist/material/Pantheon.js

@@ -274,14 +274,16 @@ export class Pantheon extends MaterialRulesPart {
     get missingMythologies() {
         return difference(new Destiny(this.game).mythologies, this.mythologies);
     }
-    onEntitySacrificed(cardIndex) {
+    onCardSacrificed(cardIndex, updateGrid = true) {
         const card = this.material(MaterialType.EntityCard).getItem(cardIndex);
         const { x, y, z } = card.location;
         const grid = this.indexGrid;
         if (grid[y][x] === cardIndex) {
             const cardUnder = this.allCards.location((l) => l.x === x && l.y === y && l.z !== z).maxBy((item) => item.location.z);
             grid[y][x] = cardUnder.length ? cardUnder.getIndex() : null;
-            this.memorize(Memory.PlayerGrid, grid, this.player);
+            if (updateGrid) {
+                this.memorize(Memory.PlayerGrid, grid, this.player);
+            }
             new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.EntitySacrificed, card: card, cardIndex });
         }
     }

package/dist/material/entity/MoveEffectRule.js

@@ -57,6 +57,7 @@ export class MoveEffectRule extends PlayerEffectRule {
     }
     onCardSacrificed(move) {
         if (this.getSacrificeToPreventMove().some((sacrificeMove) => isEqual(move, sacrificeMove))) {
+            new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex, false);
             return [this.customMove(CustomMoveType.EndEffect)];
         }
         return [];

package/dist/material/entity/SacrificeEffectRule.d.ts

@@ -7,5 +7,5 @@ export declare abstract class SacrificeEffectRule extends PlayerEffectRule {
     private getCardsAbleToSacrifice;
     getCardsToSacrifice(): Material;
     beforeItemMove(move: ItemMove): MaterialMove[];
-    onSacrifice(_move: MoveItem): MaterialMove[];
+    onSacrifice(move: MoveItem): MaterialMove[];
 }

package/dist/material/entity/SacrificeEffectRule.js

@@ -34,7 +34,8 @@ export class SacrificeEffectRule extends PlayerEffectRule {
         }
         return [];
     }
-    onSacrifice(_move) {
+    onSacrifice(move) {
+        new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex);
         return [this.customMove(CustomMoveType.EndEffect)];
     }
 }

package/dist/material/entity/SimultaneousMoveEffectRule.d.ts

@@ -2,7 +2,7 @@ import { ItemMove, Location, Material, MaterialItem, MaterialMove, MoveItem, XYC
 import { PlayerColor } from '../../PlayerColor';
 import { SimultaneousEffectRule } from './SimultaneousEffectRule';
 export declare abstract class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
-    getActivePlayerLegalMoves(player: PlayerColor): MoveItem<number, number, number>[];
+    getActivePlayerLegalMoves(player: PlayerColor): MaterialMove[];
     getSacrificeToPreventMove(player: PlayerColor): MoveItem<number, number, number>[];
     getMovementMoves(player: PlayerColor): MoveItem<number, number, number>[];
     private getCardsAbleToMove;

package/dist/material/entity/SimultaneousMoveEffectRule.js

@@ -46,6 +46,7 @@ export class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
         return [this.endPlayerTurn(move.location.player)];
     }
     onCardSacrificed(move) {
+        new Pantheon(this.game, move.location.player).onCardSacrificed(move.itemIndex, false);
         return [this.endPlayerTurn(move.location.player)];
     }
     getMovesAfterPlayersDone() {

package/dist/material/entity/SimultaneousSacrificeEffectRule.js

@@ -26,6 +26,7 @@ export class SimultaneousSacrificeEffectRule extends SimultaneousEffectRule {
         return [];
     }
     onSacrifice(move) {
+        new Pantheon(this.game, move.location.player).onCardSacrificed(move.itemIndex);
         return [this.endPlayerTurn(move.location.player)];
     }
 }

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

@@ -1,4 +1,4 @@
-import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
@@ -9,8 +9,8 @@ export declare class CaimanEffectRule extends PlayerEffectRule {
 }
 export declare class CaimanSacrificeEffectRule extends SacrificeEffectRule {
     ruleId: RuleId;
-    onRuleStart(): CustomMove[] | import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    onRuleStart(): CustomMove[] | MoveItem<number, number, number>[];
     getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(): MaterialMove[];
+    onSacrifice(move: MoveItem): MaterialMove[];
     onRuleEnd(): never[];
 }

package/dist/rules/effects/CaimanEffectRule.js

@@ -40,9 +40,11 @@ export class CaimanSacrificeEffectRule extends SacrificeEffectRule {
         const indexes = this.remind(Memory.TargetEntities);
         return this.material(MaterialType.EntityCard).index(indexes);
     }
-    onSacrifice() {
+    onSacrifice(move) {
         const moves = [];
-        moves.push(new Pantheon(this.game, this.player).gainGems(1));
+        const pantheon = new Pantheon(this.game, this.player);
+        pantheon.onCardSacrificed(move.itemIndex);
+        moves.push(pantheon.gainGems(1));
         const remaining = this.memorize(Memory.EffectCount, (count) => count - 1);
         if (!remaining) {
             moves.push(this.customMove(CustomMoveType.EndEffect));

package/dist/rules/effects/CobraEffectRule.js

@@ -3,6 +3,7 @@ import { SummonEffectRule } from '../../material/entity/PlaceCardEffectRule';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 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 CobraEffectRule extends SacrificeEffectRule {
@@ -12,6 +13,7 @@ export class CobraEffectRule extends SacrificeEffectRule {
         return super.getCardsToSacrifice().location((l) => l.x === x && l.y !== y);
     }
     onSacrifice(move) {
+        new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex);
         const cards = this.material(MaterialType.EntityCard);
         const mythology = entityMythology(cards.getItem(move.itemIndex).id.front);
         const creaturesDeck = cards.location(LocationType.CreaturesDeck).locationId(mythology).deck();

package/dist/rules/effects/CondorEffectRule.js

@@ -13,6 +13,7 @@ export class CondorEffectRule extends SacrificeEffectRule {
     onSacrifice(move) {
         const entity = this.material(MaterialType.EntityCard).getItem(move.itemIndex);
         const pantheon = new Pantheon(this.game, this.player);
+        pantheon.onCardSacrificed(move.itemIndex);
         const moves = pantheon.getSummonGains(entity.id.front, entity.location.y);
         moves.push(this.customMove(CustomMoveType.EndEffect));
         return moves;

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

@@ -6,6 +6,8 @@ export declare class DullahanEffectRule extends MoveEffectRule {
     onRuleStart(): MaterialMove[];
     getMovingCards(): import("@gamepark/rules-api").Material<number, number, number>;
     isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
+    getPlayerMoves(): MaterialMove[];
     onCardMoved(move: MoveItem): MaterialMove[];
+    onCardSacrificed(move: MoveItem): import("@gamepark/rules-api").CustomMove[];
     onRuleEnd(): never[];
 }

package/dist/rules/effects/DullahanEffectRule.js

@@ -1,3 +1,4 @@
+import { isEqual } from 'es-toolkit';
 import { CustomMoveType } from '../../CustomMoveType';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { Pantheon } from '../../material/Pantheon';
@@ -25,19 +26,43 @@ export class DullahanEffectRule extends MoveEffectRule {
     isLegalDestination(space, cardLocation) {
         return cardLocation.x === space.x && cardLocation.y === space.y - 1;
     }
+    getPlayerMoves() {
+        const moves = super.getPlayerMoves();
+        if (!this.remind(Memory.EffectCount)) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
     onCardMoved(move) {
         const moves = [];
         const pantheon = new Pantheon(this.game, this.player);
         if (pantheon.visibleEntities.location((l) => l.x === move.location.x && l.y === move.location.y).length > 0) {
             moves.push(pantheon.gainGems(1));
         }
-        this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex));
-        const count = this.memorize(Memory.EffectCount, (count) => count - 1);
-        if (count === 0) {
+        const targetEntities = this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex));
+        this.memorize(Memory.EffectCount, (count) => Math.max(0, count - 1));
+        if (targetEntities.length === 0) {
             moves.push(this.customMove(CustomMoveType.EndEffect));
         }
         return moves;
     }
+    onCardSacrificed(move) {
+        if (this.getSacrificeToPreventMove().some((sacrificeMove) => isEqual(move, sacrificeMove))) {
+            new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex, false);
+            const targetEntities = this.remind(Memory.TargetEntities);
+            if (targetEntities.includes(move.itemIndex)) {
+                const remaining = this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex));
+                this.memorize(Memory.EffectCount, (count) => Math.max(0, count - 2));
+                if (remaining.length === 0) {
+                    return [this.customMove(CustomMoveType.EndEffect)];
+                }
+            }
+            else {
+                this.memorize(Memory.EffectCount, (count) => Math.max(0, count - 1));
+            }
+        }
+        return [];
+    }
     onRuleEnd() {
         this.forget(Memory.TargetEntities);
         this.forget(Memory.EffectCount);

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

@@ -1,10 +1,10 @@
-import { MaterialMove } from '@gamepark/rules-api';
+import { MaterialMove, MoveItem } from '@gamepark/rules-api';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
 export declare class FairyEffectRule extends SacrificeEffectRule {
     ruleId: RuleId;
     playEffect(): MaterialMove[];
     getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(): MaterialMove[];
+    onSacrifice(move: MoveItem): MaterialMove[];
     onRuleEnd(): never[];
 }

package/dist/rules/effects/FairyEffectRule.js

@@ -18,7 +18,8 @@ export class FairyEffectRule extends SacrificeEffectRule {
     getCardsToSacrifice() {
         return this.material(MaterialType.EntityCard).index(this.remind(Memory.TargetEntities)[0]);
     }
-    onSacrifice() {
+    onSacrifice(move) {
+        new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex);
         const moves = [new Pantheon(this.game, this.player).gainGems(2)];
         const targets = this.memorize(Memory.TargetEntities, (targets) => targets.slice(1));
         if (!targets.length) {

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

@@ -1,4 +1,4 @@
-import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
@@ -11,6 +11,6 @@ export declare class GarudaSacrificeRule extends SacrificeEffectRule {
     ruleId: RuleId;
     onRuleStart(): MaterialMove[];
     getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(): CustomMove[];
+    onSacrifice(move: MoveItem): CustomMove[];
     onRuleEnd(): never[];
 }

package/dist/rules/effects/GarudaEffectRule.js

@@ -38,7 +38,8 @@ export class GarudaSacrificeRule extends SacrificeEffectRule {
         const plan = this.remind(Memory.TargetPlane);
         return pantheon.visibleEntities.id((id) => isCreature(id.front)).location((l) => l.y === plan);
     }
-    onSacrifice() {
+    onSacrifice(move) {
+        new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex);
         const sacrificeLeft = this.memorize(Memory.EffectCount, (count) => count - 1);
         if (sacrificeLeft) {
             return [];

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

@@ -1,7 +1,8 @@
+import { MoveItem } from '@gamepark/rules-api';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
 export declare class GorgonEffectRule 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>)[];
+    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
 }

package/dist/rules/effects/GorgonEffectRule.js

@@ -8,8 +8,9 @@ export class GorgonEffectRule extends SacrificeEffectRule {
         const { x, y } = this.card.location;
         return super.getCardsToSacrifice().location((l) => l.x === x && l.y === y + 1);
     }
-    onSacrifice() {
+    onSacrifice(move) {
         const pantheon = new Pantheon(this.game, this.player);
+        pantheon.onCardSacrificed(move.itemIndex);
         return [pantheon.gainGems(2), this.customMove(CustomMoveType.EndEffect)];
     }
 }

package/dist/rules/effects/JiangshiEffectRule.js

@@ -18,6 +18,7 @@ export class JiangshiEffectRule extends PlayerEffectRule {
     beforeItemMove(move) {
         if (isMoveItemTypeAtOnce(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
             const pantheon = new Pantheon(this.game, this.player);
+            pantheon.onPileSacrificed(move.indexes);
             return [pantheon.gainGems(2), this.customMove(CustomMoveType.EndEffect)];
         }
         return [];

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

@@ -7,6 +7,7 @@ export declare abstract class MultipleSimultaneousMoveEffectRule extends Simulta
     getTargetEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
     getEffectCount(player: PlayerColor): number;
     getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getActivePlayerLegalMoves(player: PlayerColor): MaterialMove[];
     onCardMoved(move: MoveItem): import("@gamepark/rules-api").EndPlayerTurn<number>[];
     onCardSacrificed(move: MoveItem): MaterialMove[];
     onRuleEnd(): never[];

package/dist/rules/effects/MultipleSimultaneousMoveEffectRule.js

@@ -50,13 +50,30 @@ export class MultipleSimultaneousMoveEffectRule extends SimultaneousMoveEffectRu
     getMovingCards(player) {
         return this.material(MaterialType.EntityCard).index(this.remind(Memory.TargetEntities, player));
     }
+    getActivePlayerLegalMoves(player) {
+        const moves = super.getActivePlayerLegalMoves(player);
+        if (!this.remind(Memory.EffectCount, player)) {
+            moves.push(this.endPlayerTurn(player));
+        }
+        return moves;
+    }
     onCardMoved(move) {
-        this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex), move.location.player);
-        const count = this.memorize(Memory.EffectCount, (count) => count - 1, move.location.player);
-        return count ? [] : [this.endPlayerTurn(move.location.player)];
+        const targetEntities = this.memorize(Memory.TargetEntities, (entities) => entities.filter((index) => index !== move.itemIndex), move.location.player);
+        this.memorize(Memory.EffectCount, (count) => Math.max(0, count - 1), move.location.player);
+        return targetEntities.length ? [] : [this.endPlayerTurn(move.location.player)];
     }
     onCardSacrificed(move) {
-        return this.onCardMoved(move);
+        const player = move.location.player;
+        new Pantheon(this.game, player).onCardSacrificed(move.itemIndex, false);
+        const targetEntities = this.remind(Memory.TargetEntities, player);
+        if (targetEntities.includes(move.itemIndex)) {
+            this.memorize(Memory.TargetEntities, targetEntities.filter((index) => index !== move.itemIndex), player);
+            this.memorize(Memory.EffectCount, (count) => count - 2, player);
+            return targetEntities.length > 1 ? [] : [this.endPlayerTurn(player)];
+        }
+        else {
+            return this.onCardMoved(move);
+        }
     }
     onRuleEnd() {
         this.forget(Memory.TargetEntities);

package/dist/rules/effects/NuwaEffectRule.js

@@ -38,6 +38,7 @@ export class NuwaEffectRule extends SimultaneousSacrificeEffectRule {
     }
     onSacrifice(move) {
         const player = move.location.player;
+        new Pantheon(this.game, player).onCardSacrificed(move.itemIndex);
         const creaturesLeft = this.memorize(Memory.TargetEntities, (creatures) => creatures.filter((c) => c !== move.itemIndex), player);
         return creaturesLeft.length ? [] : [this.endPlayerTurn(player)];
     }

package/dist/rules/effects/ShivaEffectRule.js

@@ -28,6 +28,7 @@ export class ShivaEffectRule extends PlayerEffectRule {
     beforeItemMove(move) {
         if (isMoveItemTypeAtOnce(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
             const pantheon = new Pantheon(this.game, this.player);
+            pantheon.onPileSacrificed(move.indexes);
             return [pantheon.gainFavor(move.indexes.length), this.customMove(CustomMoveType.EndEffect)];
         }
         return [];

package/dist/rules/effects/TianlongEffectRule.js

@@ -22,7 +22,7 @@ export class TianlongEffectRule extends MoveEffectRule {
                 { 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 [new Pantheon(this.game, this.player).spendGems(1), ...opponentsEffectRule.playEffect(), this.customMove(CustomMoveType.EndEffect)];
         }
         return [];
     }

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

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

package/dist/rules/effects/VetalaEffectRule.js

@@ -3,6 +3,7 @@ import { CustomMoveType } from '../../CustomMoveType';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 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 VetalaEffectRule extends MoveEffectRule {
@@ -27,7 +28,8 @@ export class VetalaEffectRule extends MoveEffectRule {
         const count = this.memorize(Memory.EffectCount, (count) => count - 1);
         return count > 0 ? [] : [this.customMove(CustomMoveType.EndEffect)];
     }
-    onCardSacrificed() {
+    onCardSacrificed(move) {
+        new Pantheon(this.game, this.player).onCardSacrificed(move.itemIndex, false);
         return this.onCardMoved();
     }
     onRuleEnd() {

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

@@ -1,7 +1,8 @@
+import { MoveItem } from '@gamepark/rules-api';
 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>)[];
+    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
 }

package/dist/rules/effects/ViracochaEffectRule.js

@@ -8,8 +8,9 @@ export class ViracochaEffectRule extends SacrificeEffectRule {
     getCardsToSacrifice() {
         return super.getCardsToSacrifice().id((id) => isCreature(id.front));
     }
-    onSacrifice() {
+    onSacrifice(move) {
         const pantheon = new Pantheon(this.game, this.player);
+        pantheon.onCardSacrificed(move.itemIndex);
         return [pantheon.gainFavor(2), this.customMove(CustomMoveType.EndEffect)];
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -28,5 +28,5 @@
     "@gamepark/rules-api": "~7.2.0",
     "es-toolkit": "^1.44.0"
   },
-  "gitHead": "5c5b2ef2ed4db67fdcd1bec7605ae811fd8cf51b"
+  "gitHead": "00fe0e867bb364ae75145ccd88016afa7988a3c1"
 }