@gamepark/mythologies 0.11.0 → 0.12.0

package/dist/MythologiesRules.d.ts

@@ -47,6 +47,7 @@ import { TianlongEffectRule, TianlongOpponentsEffectRule } from './rules/effects
 import { UkukuEffectRule, UkukuPlaceEffectRule } from './rules/effects/UkukuEffectRule';
 import { VetalaEffectRule } from './rules/effects/VetalaEffectRule';
 import { ViracochaEffectRule } from './rules/effects/ViracochaEffectRule';
+import { VishnuEffectRule } from './rules/effects/VishnuEffectRule';
 import { WerehyenaEffectRule } from './rules/effects/WerehyenaEffectRule';
 import { YanluoWangEffectRule } from './rules/effects/YanluoWangEffectRule';
 import { EndGameRule } from './rules/EndGameRule';
@@ -85,36 +86,37 @@ export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, M
         30: typeof CobraInvokeEffect;
         31: typeof AmmitEffectRule;
         32: typeof BennuEffectRule;
-        33: typeof ShivaEffectRule;
-        34: typeof RakshasaEffectRule;
-        35: typeof GarudaEffectRule;
-        62: typeof GarudaSacrificeRule;
-        36: typeof VetalaEffectRule;
-        37: typeof KinnaraEffectRule;
-        38: typeof KinnaraPlaceEffectRule;
-        39: typeof ViracochaEffectRule;
-        40: typeof IllapaEffectRule;
-        41: typeof IllapaSacrificeRule;
-        42: typeof CaimanEffectRule;
-        43: typeof CondorEffectRule;
-        44: typeof SupayEffectRule;
-        45: typeof UkukuEffectRule;
-        46: typeof UkukuPlaceEffectRule;
-        47: typeof YanluoWangEffectRule;
-        48: typeof NuwaEffectRule;
-        49: typeof TianlongEffectRule;
-        50: typeof TianlongOpponentsEffectRule;
-        51: typeof QilinEffectRule;
-        52: typeof FenghuangEffectRule;
-        53: typeof JiangshiEffectRule;
-        54: typeof InkosazanaEffectRule;
-        55: typeof ImpunduluEffectRule;
-        56: typeof WerehyenaEffectRule;
-        57: typeof IdloziEffectRule;
-        58: typeof FairyEffectRule;
-        59: typeof LeprechaunEffectRule;
-        60: typeof SelkieEffectRule;
-        61: typeof DullahanEffectRule;
+        33: typeof VishnuEffectRule;
+        34: typeof ShivaEffectRule;
+        35: typeof RakshasaEffectRule;
+        36: typeof GarudaEffectRule;
+        63: typeof GarudaSacrificeRule;
+        37: typeof VetalaEffectRule;
+        38: typeof KinnaraEffectRule;
+        39: typeof KinnaraPlaceEffectRule;
+        40: typeof ViracochaEffectRule;
+        41: typeof IllapaEffectRule;
+        42: typeof IllapaSacrificeRule;
+        43: typeof CaimanEffectRule;
+        44: typeof CondorEffectRule;
+        45: typeof SupayEffectRule;
+        46: typeof UkukuEffectRule;
+        47: typeof UkukuPlaceEffectRule;
+        48: typeof YanluoWangEffectRule;
+        49: typeof NuwaEffectRule;
+        50: typeof TianlongEffectRule;
+        51: typeof TianlongOpponentsEffectRule;
+        52: typeof QilinEffectRule;
+        53: typeof FenghuangEffectRule;
+        54: typeof JiangshiEffectRule;
+        55: typeof InkosazanaEffectRule;
+        56: typeof ImpunduluEffectRule;
+        57: typeof WerehyenaEffectRule;
+        58: typeof IdloziEffectRule;
+        59: typeof FairyEffectRule;
+        60: typeof LeprechaunEffectRule;
+        61: typeof SelkieEffectRule;
+        62: typeof DullahanEffectRule;
     };
     locationsStrategies: {
         2: {
@@ -151,7 +153,7 @@ export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, M
     keepMoveSecret(move: MaterialMove): boolean;
     isPlayerDestiny(move: MoveItem): boolean;
     beforeItemMove(move: ItemMove): MaterialMove<PlayerColor, MaterialType, LocationType, number>[];
-    getAutomaticMoves(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.ResolveEffects>[] | import("@gamepark/rules-api").StartRule<RuleId.ResolveEffects>[];
+    getAutomaticMoves(): import("@gamepark/rules-api").StartRule<RuleId.ResolveEffects>[] | import("@gamepark/rules-api").StartPlayerTurn<PlayerColor, RuleId.ResolveEffects>[];
     giveTime(): number;
     getScore(player: PlayerColor): number;
     getTieBreaker(tieBreaker: number, player: PlayerColor): number | undefined;

package/dist/MythologiesRules.js

@@ -52,6 +52,7 @@ import { TriggerEffectsRule } from './rules/effects/TriggerEffectsRule';
 import { UkukuEffectRule, UkukuPlaceEffectRule } from './rules/effects/UkukuEffectRule';
 import { VetalaEffectRule } from './rules/effects/VetalaEffectRule';
 import { ViracochaEffectRule } from './rules/effects/ViracochaEffectRule';
+import { VishnuEffectRule } from './rules/effects/VishnuEffectRule';
 import { WerehyenaEffectRule } from './rules/effects/WerehyenaEffectRule';
 import { YanluoWangEffectRule } from './rules/effects/YanluoWangEffectRule';
 import { EndGameRule } from './rules/EndGameRule';
@@ -90,6 +91,7 @@ export class MythologiesRules extends SecretMaterialRules {
         [RuleId.CobraInvokeEffect]: CobraInvokeEffect,
         [RuleId.AmmitEffect]: AmmitEffectRule,
         [RuleId.BennuEffect]: BennuEffectRule,
+        [RuleId.VishnuEffect]: VishnuEffectRule,
         [RuleId.ShivaEffect]: ShivaEffectRule,
         [RuleId.RakshasaEffect]: RakshasaEffectRule,
         [RuleId.GarudaEffect]: GarudaEffectRule,
@@ -190,7 +192,9 @@ export class MythologiesRules extends SecretMaterialRules {
         return super.beforeItemMove(move);
     }
     getAutomaticMoves() {
-        if (!this.remind(Memory.OngoingEffect) && this.game.rule?.id !== RuleId.ResolveEffects && this.remind(Memory.PendingEffects).length) {
+        if (!this.remind(Memory.OngoingEffect) &&
+            this.game.rule?.id !== RuleId.ResolveEffects &&
+            this.remind(Memory.PendingEffects).length) {
             return new ResolveEffectsRule(this.game).startEffectsResolution();
         }
         return [];

package/dist/material/Entity.d.ts

@@ -11,8 +11,8 @@ export declare enum Entity {
     Centaur = 6,
     Gorgon = 7,
     Cyclops = 8,
-    Chimera = 9,
-    Griffin = 10,
+    Griffin = 9,
+    Chimera = 10,
     Odin = 11,
     Thor = 12,
     Loki = 13,

package/dist/material/Entity.js

@@ -8,8 +8,8 @@ export var Entity;
     Entity[Entity["Centaur"] = 6] = "Centaur";
     Entity[Entity["Gorgon"] = 7] = "Gorgon";
     Entity[Entity["Cyclops"] = 8] = "Cyclops";
-    Entity[Entity["Chimera"] = 9] = "Chimera";
-    Entity[Entity["Griffin"] = 10] = "Griffin";
+    Entity[Entity["Griffin"] = 9] = "Griffin";
+    Entity[Entity["Chimera"] = 10] = "Chimera";
     Entity[Entity["Odin"] = 11] = "Odin";
     Entity[Entity["Thor"] = 12] = "Thor";
     Entity[Entity["Loki"] = 13] = "Loki";

package/dist/material/Pantheon.d.ts

@@ -29,7 +29,7 @@ export declare class Pantheon extends MaterialRulesPart {
     updateGrid(gridAfter?: (number | null)[][]): TriggerEvent[];
     private getEntitiesMoved;
     private getEntitiesCrushed;
-    gainBonus(grid?: (number | null)[][]): MoveItem[];
+    triggerBonusGains(grid?: (number | null)[][]): void;
     gainLineBonus(y: number): MoveItem<number, number, number>[];
     gainColumnBonus(x: number): MoveItem<number, number, number>[];
     getBonusGem(y: number): Material<number, number, number>;

package/dist/material/Pantheon.js

@@ -6,7 +6,7 @@ import { PermanentEffectsRule } from '../rules/effects/PermanentEffectsRule';
 import { TriggerEffectsRule } from '../rules/effects/TriggerEffectsRule';
 import { Destiny } from './Destiny';
 import { entityMythology, isGod } from './Entity';
-import { isTriggeredEffect, LineEventType, TriggerEventType } from './entity/Effect';
+import { isTriggeredEffect, LineEventType, PendingEffectsType, TriggerEventType } from './entity/Effect';
 import { entities, getEffects } from './entity/EntityDescription';
 import { LocationType } from './LocationType';
 import { MaterialType } from './MaterialType';
@@ -99,14 +99,13 @@ export class Pantheon extends MaterialRulesPart {
         const grid = this.indexGrid;
         const crush = grid[move.location.y][move.location.x] !== null;
         grid[move.location.y][move.location.x] = move.itemIndex;
-        moves.push(...this.gainBonus(grid));
         const triggerEffectsRule = new TriggerEffectsRule(this.game);
-        triggerEffectsRule.triggerCardEffect(move.itemIndex, location, { type: TriggerEventType.SelfPlaced, crush });
-        const triggerEvents = this.updateGrid(grid);
+        triggerEffectsRule.triggerCardEffect(move.itemIndex, location, { type: TriggerEventType.SelfPlaced, crush }, entity);
         const invoked = this.isInvoke;
         if (invoked) {
             moves.push(...this.onInvoke(move));
         }
+        const triggerEvents = this.updateGrid(grid);
         triggerEvents.push({ type: TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity, location, invoked });
         if (triggerEvents.length) {
             triggerEffectsRule.triggerEffects(...triggerEvents);
@@ -117,6 +116,7 @@ export class Pantheon extends MaterialRulesPart {
         return new MythologiesRules(this.game).delegate().isInvoke;
     }
     updateGrid(gridAfter = this.indexGrid) {
+        this.triggerBonusGains(gridAfter);
         const gridBefore = this.remind(Memory.PlayerGrid, this.player) ?? this.indexGrid;
         this.memorize(Memory.PlayerGrid, gridAfter, this.player);
         const triggerEvents = [];
@@ -165,17 +165,23 @@ export class Pantheon extends MaterialRulesPart {
         }
         return entities;
     }
-    gainBonus(grid = this.indexGrid) {
-        const moves = [];
+    triggerBonusGains(grid = this.indexGrid) {
+        const effect = { type: PendingEffectsType.BonusGains, player: this.player, lines: [], columns: [] };
         const fullLines = range(0, 3).filter((y) => !grid[y].includes(null));
         for (const y of fullLines) {
-            moves.push(...this.gainLineBonus(y));
+            if (this.getBonusGem(y).length) {
+                effect.lines.push(y);
+            }
         }
         const fullColumns = range(0, 3).filter((x) => grid.every((line) => line[x] !== null));
         for (const x of fullColumns) {
-            moves.push(...this.gainColumnBonus(x));
+            if (this.getBonusFavor(x).length) {
+                effect.columns.push(x);
+            }
+        }
+        if (effect.lines.length || effect.columns.length) {
+            this.remind(Memory.PendingEffects).unshift(effect);
         }
-        return moves;
     }
     gainLineBonus(y) {
         const bonusGem = this.getBonusGem(y);
@@ -217,7 +223,10 @@ export class Pantheon extends MaterialRulesPart {
                 }
             }
         }
-        moves.push(...this.getInvokeGains(entity, move.location.y));
+        const invokeGain = entities[entity].invoke[move.location.y];
+        if (invokeGain.favor || invokeGain.gem) {
+            this.remind(Memory.PendingEffects).unshift({ type: PendingEffectsType.InvokeGain, player: this.player, entity, line: move.location.y });
+        }
         return moves;
     }
     getInvokeGains(entity, line) {

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

@@ -1,11 +1,11 @@
 import { MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
 import { PlayerColor } from '../../PlayerColor';
 import { EntityId } from '../Entity';
-import { EffectRule, PendingEffect, TriggerEvent } from './Effect';
+import { CardEffect, EffectRule, TriggerEvent } from './Effect';
 export declare abstract class AutoEffectRule extends MaterialRulesPart implements EffectRule {
     canPlayEffect: () => boolean;
     abstract playEffect(): MaterialMove[];
-    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
+    getEffect<Event extends TriggerEvent>(): CardEffect<Event>;
     get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
     get player(): PlayerColor;
 }

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

@@ -98,9 +98,33 @@ export type EndOfTurn = {
 };
 export declare const isEndOfMyTurn: (event: TriggerEvent, { cardLocation }: TriggerEventContext) => event is EndOfTurn;
 export type TriggerEvent = EndOfGameEvent | SelfPlaced | EntityPlaced | LineEvent | ColumnEvent | Infinite | EntityCrushed | EntitySacrificed | EntitiesMoved | EndOfTurn;
-export type PendingEffect<Event extends TriggerEvent = TriggerEvent> = {
+export type PlayerPendingEffects<Event extends TriggerEvent = TriggerEvent> = PlayerPendingCardsEffects<Event> | InvokeGainEffect | BonusGainEffects;
+export declare enum PendingEffectsType {
+    CardsEffects = 1,
+    InvokeGain = 2,
+    BonusGains = 3
+}
+export type PlayerPendingCardsEffects<Event extends TriggerEvent = TriggerEvent> = {
+    type: PendingEffectsType.CardsEffects;
+    player: PlayerColor;
+    effects: CardEffect<Event>[];
+};
+export type CardEffect<Event extends TriggerEvent = TriggerEvent> = {
     cardIndex: number;
     effectIndex: number;
     triggerEvent: Event;
     auto: boolean;
+    count?: number;
+};
+export type InvokeGainEffect = {
+    type: PendingEffectsType.InvokeGain;
+    player: PlayerColor;
+    entity: Entity;
+    line: number;
+};
+export type BonusGainEffects = {
+    type: PendingEffectsType.BonusGains;
+    player: PlayerColor;
+    lines: number[];
+    columns: number[];
 };

package/dist/material/entity/Effect.js

@@ -24,3 +24,9 @@ export const oncePerTurn = (event) => event.type === TriggerEventType.Infinite;
 export const isCrushed = (event, { cardIndex }) => event.type === TriggerEventType.EntityCrushed && event.cardIndex === cardIndex;
 export const isSacrificed = (event, { cardIndex }) => event.type === TriggerEventType.EntitySacrificed && event.cardIndex === cardIndex;
 export const isEndOfMyTurn = (event, { cardLocation }) => event.type === TriggerEventType.EndOfTurn && event.player === cardLocation.player;
+export var PendingEffectsType;
+(function (PendingEffectsType) {
+    PendingEffectsType[PendingEffectsType["CardsEffects"] = 1] = "CardsEffects";
+    PendingEffectsType[PendingEffectsType["InvokeGain"] = 2] = "InvokeGain";
+    PendingEffectsType[PendingEffectsType["BonusGains"] = 3] = "BonusGains";
+})(PendingEffectsType || (PendingEffectsType = {}));

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

@@ -14,5 +14,5 @@ export declare abstract class MoveEffectRule extends PlayerEffectRule {
     onCardMoved(_move: MoveItem): MaterialMove[];
     onCardSacrificed(move: MoveItem): MaterialMove[];
     onEndEffect(): MaterialMove[];
-    updateGridAfterMoves(): MoveItem[];
+    updateGridAfterMoves(): void;
 }

package/dist/material/entity/MoveEffectRule.js

@@ -63,11 +63,11 @@ export class MoveEffectRule extends PlayerEffectRule {
         return [];
     }
     onEndEffect() {
-        return [...this.updateGridAfterMoves(), ...super.onEndEffect()];
+        this.updateGridAfterMoves();
+        return super.onEndEffect();
     }
     updateGridAfterMoves() {
         const pantheon = new Pantheon(this.game, this.player);
         new TriggerEffectsRule(this.game).triggerEffects(...pantheon.updateGrid());
-        return pantheon.gainBonus();
     }
 }

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

@@ -1,8 +1,10 @@
 import { ItemMove, Material, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
 import { PlayerEffectRule } from './PlayerEffectRule';
 export declare abstract class PlaceCardEffectRule extends PlayerEffectRule {
+    times: number;
     canPlayEffect(cardIndex: number): boolean;
     playEffect(): MaterialMove[];
+    onRuleStart(): MaterialMove[];
     getPlayerMoves(cardIndex?: number): MaterialMove[];
     abstract getCardsToPlace(cardIndex: number): Material;
     getAvailableDestinations(_cardIndex: number): XYCoordinates[];

package/dist/material/entity/PlaceCardEffectRule.js

@@ -1,11 +1,14 @@
 import { isMoveItemType } from '@gamepark/rules-api';
 import { CustomMoveType } from '../../CustomMoveType';
+import { Memory } from '../../Memory';
 import { isGod } from '../Entity';
 import { LocationType } from '../LocationType';
 import { MaterialType } from '../MaterialType';
 import { Pantheon } from '../Pantheon';
+import { PendingEffectsType } from './Effect';
 import { PlayerEffectRule } from './PlayerEffectRule';
 export class PlaceCardEffectRule extends PlayerEffectRule {
+    times = 1;
     canPlayEffect(cardIndex) {
         return this.getPlayerMoves(cardIndex).length > 0;
     }
@@ -14,6 +17,18 @@ export class PlaceCardEffectRule extends PlayerEffectRule {
             return [];
         return super.playEffect();
     }
+    onRuleStart() {
+        const count = this.getEffect().count ?? 1;
+        if (count < this.times) {
+            const repeatEffect = {
+                type: PendingEffectsType.CardsEffects,
+                player: this.player,
+                effects: [{ ...this.getEffect(), count: count + 1 }]
+            };
+            this.memorize(Memory.PendingEffects, (effects) => [repeatEffect, ...effects]);
+        }
+        return super.onRuleStart();
+    }
     getPlayerMoves(cardIndex = this.getEffect().cardIndex) {
         const player = this.material(MaterialType.EntityCard).getItem(cardIndex).location.player;
         const cards = this.getCardsToPlace(cardIndex);

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

@@ -1,14 +1,14 @@
 import { CustomMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
 import { RuleId } from '../../rules/RuleId';
 import { EntityId } from '../Entity';
-import { EffectRule, PendingEffect, TriggerEvent } from './Effect';
+import { CardEffect, EffectRule, TriggerEvent } from './Effect';
 export declare abstract class PlayerEffectRule extends PlayerTurnRule implements EffectRule {
     canPlayEffect(_cardIndex: number): boolean;
     ruleId?: RuleId;
     playEffect(): MaterialMove[];
     onRuleStart(): MaterialMove[];
     get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
-    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
+    getEffect<Event extends TriggerEvent>(): CardEffect<Event>;
     onCustomMove(move: CustomMove): MaterialMove[];
     onEndEffect(): MaterialMove[];
 }

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

@@ -2,7 +2,7 @@ import { CustomMove, MaterialMove, SimultaneousRule } from '@gamepark/rules-api'
 import { PlayerColor } from '../../PlayerColor';
 import { RuleId } from '../../rules/RuleId';
 import { EntityId } from '../Entity';
-import { EffectRule, PendingEffect, TriggerEvent } from './Effect';
+import { CardEffect, EffectRule, TriggerEvent } from './Effect';
 export declare abstract class SimultaneousEffectRule extends SimultaneousRule implements EffectRule {
     canPlayEffect(_cardIndex: number): boolean;
     ruleId?: RuleId;
@@ -11,7 +11,7 @@ export declare abstract class SimultaneousEffectRule extends SimultaneousRule im
     getAffectedPlayers(): PlayerColor[];
     isOpponent(player: PlayerColor): boolean;
     get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
-    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
+    getEffect<Event extends TriggerEvent>(): CardEffect<Event>;
     getMovesAfterPlayersDone(): MaterialMove[];
     onCustomMove(move: CustomMove): MaterialMove[];
     onEndEffect(): MaterialMove[];

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

@@ -13,5 +13,5 @@ export declare abstract class SimultaneousMoveEffectRule extends SimultaneousEff
     onCardMoved(move: MoveItem): MaterialMove[];
     onCardSacrificed(move: MoveItem): MaterialMove[];
     getMovesAfterPlayersDone(): MaterialMove[];
-    updatePlayersGrids(): MoveItem[];
+    updatePlayersGrids(): void;
 }

package/dist/material/entity/SimultaneousMoveEffectRule.js

@@ -49,17 +49,16 @@ export class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
         return [this.endPlayerTurn(move.location.player)];
     }
     getMovesAfterPlayersDone() {
-        return [...this.updatePlayersGrids(), ...super.getMovesAfterPlayersDone()];
+        this.updatePlayersGrids();
+        return super.getMovesAfterPlayersDone();
     }
     updatePlayersGrids() {
-        const moves = [];
         const events = [];
-        for (const player of this.game.players) {
+        const triggerEffectsRule = new TriggerEffectsRule(this.game);
+        for (const player of triggerEffectsRule.getPlayersByEffectPriorityOrder()) {
             const pantheon = new Pantheon(this.game, player);
             events.push(...pantheon.updateGrid());
-            moves.push(...pantheon.gainBonus());
         }
-        new TriggerEffectsRule(this.game).triggerEffects(...events);
-        return moves;
+        triggerEffectsRule.triggerEffects(...events);
     }
 }

package/dist/material/entity/hindu/Vishnu.js

@@ -1,20 +1,9 @@
-import { Destiny } from '../../Destiny';
-import { LocationType } from '../../LocationType';
-import { Pantheon } from '../../Pantheon';
+import { VishnuEffectRule } from '../../../rules/effects/VishnuEffectRule';
 import { isPlaced } from '../Effect';
-import { PlayerEffectRule } from '../PlayerEffectRule';
 export const Vishnu = {
     invoke: [{}, { gem: 1, favor: 1 }, { gem: 1 }],
     effect: {
         trigger: isPlaced,
-        rule: class VishnuEffectRule extends PlayerEffectRule {
-            playEffect() {
-                const godsToExile = new Destiny(this.game).cardsWithoutToken.location(LocationType.SanctuaryGodSpot);
-                if (!godsToExile.length)
-                    return [];
-                const pantheon = new Pantheon(this.game, this.player);
-                return [...godsToExile.deleteItems(), pantheon.gainFavor(godsToExile.length * 2)];
-            }
-        }
+        rule: VishnuEffectRule
     }
 };

package/dist/rules/EndGameRule.js

@@ -10,7 +10,7 @@ export class EndGameRule extends PlayerTurnRule {
         new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.EndOfGame });
         const pendingEffects = this.remind(Memory.PendingEffects);
         if (pendingEffects.length) {
-            const cardIndex = pendingEffects[0][0].cardIndex;
+            const cardIndex = pendingEffects[0].effects[0].cardIndex;
             const player = this.material(MaterialType.EntityCard).getItem(cardIndex).location.player;
             return [this.startPlayerTurn(RuleId.ResolveEffects, player)];
         }

package/dist/rules/PlaceCardsRule.d.ts

@@ -1,10 +1,10 @@
 import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
-import { PendingEffect } from '../material/entity/Effect';
+import { CardEffect } from '../material/entity/Effect';
 import { RuleId } from './RuleId';
 export declare class PlaceCardsRule extends PlayerTurnRule {
     isInvoke: boolean;
     getPlayerMoves(): MaterialMove[];
-    get infiniteEffects(): PendingEffect[];
+    get infiniteEffects(): CardEffect[];
     isOncePerTurnAvailable(cardIndex: number): boolean;
     beforeItemMove(move: ItemMove): MaterialMove[];
     onCustomMove(move: CustomMove): MaterialMove[];

package/dist/rules/PlaceCardsRule.js

@@ -72,7 +72,7 @@ export class PlaceCardsRule extends PlayerTurnRule {
         }
         else if (move.type === CustomMoveType.PlayEffect) {
             this.memorize(Memory.PendingRule, this.game.rule);
-            return new ResolveEffectsRule(this.game).onPlayEffect(move.data);
+            return new ResolveEffectsRule(this.game).playEffect(move.data);
         }
         else if (move.type === CustomMoveType.EndEffect) {
             return new ResolveEffectsRule(this.game).onEndEffect();

package/dist/rules/RuleId.d.ts

@@ -28,36 +28,37 @@ export declare enum RuleId {
     CobraInvokeEffect = 30,
     AmmitEffect = 31,
     BennuEffect = 32,
-    ShivaEffect = 33,
-    RakshasaEffect = 34,
-    GarudaEffect = 35,
-    VetalaEffect = 36,
-    KinnaraEffect = 37,
-    KinnaraPlaceEffect = 38,
-    ViracochaEffect = 39,
-    IllapaEffect = 40,
-    IllapaSacrifice = 41,
-    CaimanEffect = 42,
-    CondorEffect = 43,
-    SupayEffect = 44,
-    UkukuEffect = 45,
-    UkukuPlaceEffect = 46,
-    YanluoWangEffect = 47,
-    NuwaEffect = 48,
-    TianlongEffect = 49,
-    TianlongOpponentsEffect = 50,
-    QilinEffect = 51,
-    FenghuangEffect = 52,
-    JiangshiEffect = 53,
-    InkosazanaEffect = 54,
-    ImpunduluEffect = 55,
-    WerehyenaEffect = 56,
-    IdloziEffect = 57,
-    FairyEffect = 58,
-    LeprechaunEffect = 59,
-    SelkieEffect = 60,
-    DullahanEffect = 61,
-    GarudaSacrifice = 62,
+    VishnuEffect = 33,
+    ShivaEffect = 34,
+    RakshasaEffect = 35,
+    GarudaEffect = 36,
+    VetalaEffect = 37,
+    KinnaraEffect = 38,
+    KinnaraPlaceEffect = 39,
+    ViracochaEffect = 40,
+    IllapaEffect = 41,
+    IllapaSacrifice = 42,
+    CaimanEffect = 43,
+    CondorEffect = 44,
+    SupayEffect = 45,
+    UkukuEffect = 46,
+    UkukuPlaceEffect = 47,
+    YanluoWangEffect = 48,
+    NuwaEffect = 49,
+    TianlongEffect = 50,
+    TianlongOpponentsEffect = 51,
+    QilinEffect = 52,
+    FenghuangEffect = 53,
+    JiangshiEffect = 54,
+    InkosazanaEffect = 55,
+    ImpunduluEffect = 56,
+    WerehyenaEffect = 57,
+    IdloziEffect = 58,
+    FairyEffect = 59,
+    LeprechaunEffect = 60,
+    SelkieEffect = 61,
+    DullahanEffect = 62,
+    GarudaSacrifice = 63,
     Mythology = 1000,
     Creature = 1001,
     Divinity = 1002,

package/dist/rules/RuleId.js

@@ -29,36 +29,37 @@ export var RuleId;
     RuleId[RuleId["CobraInvokeEffect"] = 30] = "CobraInvokeEffect";
     RuleId[RuleId["AmmitEffect"] = 31] = "AmmitEffect";
     RuleId[RuleId["BennuEffect"] = 32] = "BennuEffect";
-    RuleId[RuleId["ShivaEffect"] = 33] = "ShivaEffect";
-    RuleId[RuleId["RakshasaEffect"] = 34] = "RakshasaEffect";
-    RuleId[RuleId["GarudaEffect"] = 35] = "GarudaEffect";
-    RuleId[RuleId["VetalaEffect"] = 36] = "VetalaEffect";
-    RuleId[RuleId["KinnaraEffect"] = 37] = "KinnaraEffect";
-    RuleId[RuleId["KinnaraPlaceEffect"] = 38] = "KinnaraPlaceEffect";
-    RuleId[RuleId["ViracochaEffect"] = 39] = "ViracochaEffect";
-    RuleId[RuleId["IllapaEffect"] = 40] = "IllapaEffect";
-    RuleId[RuleId["IllapaSacrifice"] = 41] = "IllapaSacrifice";
-    RuleId[RuleId["CaimanEffect"] = 42] = "CaimanEffect";
-    RuleId[RuleId["CondorEffect"] = 43] = "CondorEffect";
-    RuleId[RuleId["SupayEffect"] = 44] = "SupayEffect";
-    RuleId[RuleId["UkukuEffect"] = 45] = "UkukuEffect";
-    RuleId[RuleId["UkukuPlaceEffect"] = 46] = "UkukuPlaceEffect";
-    RuleId[RuleId["YanluoWangEffect"] = 47] = "YanluoWangEffect";
-    RuleId[RuleId["NuwaEffect"] = 48] = "NuwaEffect";
-    RuleId[RuleId["TianlongEffect"] = 49] = "TianlongEffect";
-    RuleId[RuleId["TianlongOpponentsEffect"] = 50] = "TianlongOpponentsEffect";
-    RuleId[RuleId["QilinEffect"] = 51] = "QilinEffect";
-    RuleId[RuleId["FenghuangEffect"] = 52] = "FenghuangEffect";
-    RuleId[RuleId["JiangshiEffect"] = 53] = "JiangshiEffect";
-    RuleId[RuleId["InkosazanaEffect"] = 54] = "InkosazanaEffect";
-    RuleId[RuleId["ImpunduluEffect"] = 55] = "ImpunduluEffect";
-    RuleId[RuleId["WerehyenaEffect"] = 56] = "WerehyenaEffect";
-    RuleId[RuleId["IdloziEffect"] = 57] = "IdloziEffect";
-    RuleId[RuleId["FairyEffect"] = 58] = "FairyEffect";
-    RuleId[RuleId["LeprechaunEffect"] = 59] = "LeprechaunEffect";
-    RuleId[RuleId["SelkieEffect"] = 60] = "SelkieEffect";
-    RuleId[RuleId["DullahanEffect"] = 61] = "DullahanEffect";
-    RuleId[RuleId["GarudaSacrifice"] = 62] = "GarudaSacrifice";
+    RuleId[RuleId["VishnuEffect"] = 33] = "VishnuEffect";
+    RuleId[RuleId["ShivaEffect"] = 34] = "ShivaEffect";
+    RuleId[RuleId["RakshasaEffect"] = 35] = "RakshasaEffect";
+    RuleId[RuleId["GarudaEffect"] = 36] = "GarudaEffect";
+    RuleId[RuleId["VetalaEffect"] = 37] = "VetalaEffect";
+    RuleId[RuleId["KinnaraEffect"] = 38] = "KinnaraEffect";
+    RuleId[RuleId["KinnaraPlaceEffect"] = 39] = "KinnaraPlaceEffect";
+    RuleId[RuleId["ViracochaEffect"] = 40] = "ViracochaEffect";
+    RuleId[RuleId["IllapaEffect"] = 41] = "IllapaEffect";
+    RuleId[RuleId["IllapaSacrifice"] = 42] = "IllapaSacrifice";
+    RuleId[RuleId["CaimanEffect"] = 43] = "CaimanEffect";
+    RuleId[RuleId["CondorEffect"] = 44] = "CondorEffect";
+    RuleId[RuleId["SupayEffect"] = 45] = "SupayEffect";
+    RuleId[RuleId["UkukuEffect"] = 46] = "UkukuEffect";
+    RuleId[RuleId["UkukuPlaceEffect"] = 47] = "UkukuPlaceEffect";
+    RuleId[RuleId["YanluoWangEffect"] = 48] = "YanluoWangEffect";
+    RuleId[RuleId["NuwaEffect"] = 49] = "NuwaEffect";
+    RuleId[RuleId["TianlongEffect"] = 50] = "TianlongEffect";
+    RuleId[RuleId["TianlongOpponentsEffect"] = 51] = "TianlongOpponentsEffect";
+    RuleId[RuleId["QilinEffect"] = 52] = "QilinEffect";
+    RuleId[RuleId["FenghuangEffect"] = 53] = "FenghuangEffect";
+    RuleId[RuleId["JiangshiEffect"] = 54] = "JiangshiEffect";
+    RuleId[RuleId["InkosazanaEffect"] = 55] = "InkosazanaEffect";
+    RuleId[RuleId["ImpunduluEffect"] = 56] = "ImpunduluEffect";
+    RuleId[RuleId["WerehyenaEffect"] = 57] = "WerehyenaEffect";
+    RuleId[RuleId["IdloziEffect"] = 58] = "IdloziEffect";
+    RuleId[RuleId["FairyEffect"] = 59] = "FairyEffect";
+    RuleId[RuleId["LeprechaunEffect"] = 60] = "LeprechaunEffect";
+    RuleId[RuleId["SelkieEffect"] = 61] = "SelkieEffect";
+    RuleId[RuleId["DullahanEffect"] = 62] = "DullahanEffect";
+    RuleId[RuleId["GarudaSacrifice"] = 63] = "GarudaSacrifice";
     RuleId[RuleId["Mythology"] = 1000] = "Mythology";
     RuleId[RuleId["Creature"] = 1001] = "Creature";
     RuleId[RuleId["Divinity"] = 1002] = "Divinity";

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

@@ -3,7 +3,7 @@ import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
 import { RuleId } from '../RuleId';
 export declare class AnubisEffectRule extends InvokeEffectRule {
     ruleId: RuleId;
-    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+    times: number;
     getCardsToPlace(): Material;
     getAvailableDestinations(): import("@gamepark/rules-api").XYCoordinates[];
 }

package/dist/rules/effects/AnubisEffectRule.js

@@ -1,20 +1,10 @@
 import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
 import { LocationType } from '../../material/LocationType';
 import { MaterialType } from '../../material/MaterialType';
-import { Memory } from '../../Memory';
 import { RuleId } from '../RuleId';
 export class AnubisEffectRule extends InvokeEffectRule {
     ruleId = RuleId.AnubisEffect;
-    onRuleStart() {
-        if (!this.remind(Memory.EffectCount)) {
-            this.remind(Memory.PendingEffects).unshift([this.getEffect()]);
-            this.memorize(Memory.EffectCount, true);
-        }
-        else {
-            this.forget(Memory.EffectCount);
-        }
-        return super.onRuleStart();
-    }
+    times = 2;
     getCardsToPlace() {
         return this.material(MaterialType.EntityCard).location(LocationType.PlayerDiscard);
     }

package/dist/rules/effects/AthenaEffectRule.js

@@ -39,7 +39,7 @@ export class AthenaEffectRule extends PlayerEffectRule {
     onEndEffect() {
         const pantheon = new Pantheon(this.game, this.player);
         new TriggerEffectsRule(this.game).triggerEffects(...pantheon.updateGrid());
-        return [...pantheon.gainBonus(), ...super.onEndEffect()];
+        return super.onEndEffect();
     }
     onRuleEnd() {
         this.forget(Memory.TargetLocations);

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

@@ -1,4 +1,4 @@
-import { Location, Material, MaterialMove, XYCoordinates } from '@gamepark/rules-api';
+import { Location, Material, XYCoordinates } from '@gamepark/rules-api';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { SimultaneousSacrificeEffectRule } from '../../material/entity/SimultaneousSacrificeEffectRule';
 import { PlayerColor } from '../../PlayerColor';
@@ -7,7 +7,7 @@ export declare class CentaurEffectRule extends MoveEffectRule {
     ruleId: RuleId;
     getMovingCards(effectCardIndex?: number): Material;
     isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
-    onEndEffect(): MaterialMove[];
+    onEndEffect(): import("@gamepark/rules-api").MaterialMove[];
 }
 export declare class CentaurEffectSacrificeRule extends SimultaneousSacrificeEffectRule {
     ruleId: RuleId;

package/dist/rules/effects/CentaurEffectRule.js

@@ -4,7 +4,6 @@ import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { SimultaneousSacrificeEffectRule } from '../../material/entity/SimultaneousSacrificeEffectRule';
 import { MaterialType } from '../../material/MaterialType';
 import { Pantheon } from '../../material/Pantheon';
-import { Memory } from '../../Memory';
 import { RuleId } from '../RuleId';
 import { TriggerEffectsRule } from './TriggerEffectsRule';
 export class CentaurEffectRule extends MoveEffectRule {
@@ -18,15 +17,13 @@ export class CentaurEffectRule extends MoveEffectRule {
     onEndEffect() {
         const pantheon = new Pantheon(this.game, this.player);
         new TriggerEffectsRule(this.game).triggerEffects(...pantheon.updateGrid());
-        const moves = pantheon.gainBonus();
-        moves.push(...new CentaurEffectSacrificeRule(this.game).playEffect());
-        return moves;
+        return new CentaurEffectSacrificeRule(this.game).playEffect();
     }
 }
 export class CentaurEffectSacrificeRule extends SimultaneousSacrificeEffectRule {
     ruleId = RuleId.CentaurEffectSacrifice;
     getCardsToSacrifice(player) {
-        const cardIndex = this.remind(Memory.OngoingEffect).cardIndex;
+        const cardIndex = this.getEffect().cardIndex;
         return super
             .getCardsToSacrifice(player)
             .index((index) => index !== cardIndex)

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

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

package/dist/rules/effects/InkosazanaEffectRule.js

@@ -1,20 +1,10 @@
 import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
 import { LocationType } from '../../material/LocationType';
 import { MaterialType } from '../../material/MaterialType';
-import { Memory } from '../../Memory';
 import { RuleId } from '../RuleId';
 export class InkosazanaEffectRule extends InvokeEffectRule {
     ruleId = RuleId.InkosazanaEffect;
-    onRuleStart() {
-        if (!this.remind(Memory.EffectCount)) {
-            this.remind(Memory.PendingEffects).unshift([this.getEffect()]);
-            this.memorize(Memory.EffectCount, true);
-        }
-        else {
-            this.forget(Memory.EffectCount);
-        }
-        return super.onRuleStart();
-    }
+    times = 2;
     getCardsToPlace() {
         return this.material(MaterialType.EntityCard).location(LocationType.PlayerDiscard).player(this.player);
     }

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

@@ -10,5 +10,6 @@ export declare abstract class MultipleSimultaneousMoveEffectRule extends Simulta
     onCardMoved(move: MoveItem): import("@gamepark/rules-api").EndPlayerTurn<number>[];
     onCardSacrificed(move: MoveItem): MaterialMove[];
     onRuleEnd(): never[];
-    updatePlayersGrids(): MoveItem[];
+    getMovesAfterPlayersDone(): MaterialMove[];
+    collectOpponentBonuses(): MoveItem[];
 }

package/dist/rules/effects/MultipleSimultaneousMoveEffectRule.js

@@ -1,3 +1,6 @@
+import { partition } from 'es-toolkit';
+import { CustomMoveType } from '../../CustomMoveType';
+import { PendingEffectsType } from '../../material/entity/Effect';
 import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
 import { LocationType } from '../../material/LocationType';
 import { MaterialType } from '../../material/MaterialType';
@@ -60,12 +63,34 @@ export class MultipleSimultaneousMoveEffectRule extends SimultaneousMoveEffectRu
         this.forget(Memory.EffectCount);
         return [];
     }
-    updatePlayersGrids() {
-        const gainBonusMoves = super.updatePlayersGrids();
+    getMovesAfterPlayersDone() {
+        this.updatePlayersGrids();
+        return [...this.collectOpponentBonuses(), this.customMove(CustomMoveType.EndEffect)];
+    }
+    collectOpponentBonuses() {
+        const moves = [];
         const cardOwner = this.card.location.player;
-        for (const gainBonusMove of gainBonusMoves) {
-            gainBonusMove.location.player = cardOwner;
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        const [bonusGains, otherEffects] = partition(pendingEffects, (effect) => effect.type === PendingEffectsType.BonusGains && effect.player !== cardOwner);
+        this.memorize(Memory.PendingEffects, otherEffects);
+        for (const bonusGain of bonusGains) {
+            if (bonusGain.type === PendingEffectsType.BonusGains) {
+                for (const y of bonusGain.lines) {
+                    moves.push(this.material(MaterialType.GemToken)
+                        .location(LocationType.PantheonLineBonus)
+                        .player(bonusGain.player)
+                        .location((l) => l.y === y)
+                        .moveItem({ type: LocationType.PlayerGems, player: cardOwner }));
+                }
+                for (const x of bonusGain.columns) {
+                    moves.push(this.material(MaterialType.FavorToken)
+                        .location(LocationType.PantheonColumnBonus)
+                        .player(bonusGain.player)
+                        .location((l) => l.x === x)
+                        .moveItem({ type: LocationType.PlayerFavor, player: cardOwner }));
+                }
+            }
         }
-        return gainBonusMoves;
+        return moves;
     }
 }

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 { 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").StartPlayerTurn<number, RuleId.ResolveEffects>[] | import("@gamepark/rules-api").StartRule<RuleId.ResolveEffects>[];
-    onRuleStart(_move: RuleMove, previousRule: RuleStep): CustomMove[];
-    getPlayerMoves(): CustomMove[];
+    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(pendingEffect: PendingEffect): MaterialMove[];
-    playEffect(pendingEffect: PendingEffect): MaterialMove[];
+    onPlayEffect(effect: CardEffect): MaterialMove[];
+    playEffect(cardEffect: CardEffect): MaterialMove[];
     onEndEffect(): MaterialMove[];
 }

package/dist/rules/effects/ResolveEffectsRule.js

@@ -1,36 +1,97 @@
-import { MoveKind, PlayerTurnRule } from '@gamepark/rules-api';
+import { isMoveItem, MoveKind, PlayerTurnRule } from '@gamepark/rules-api';
 import { isEqual } from 'es-toolkit';
 import { CustomMoveType } from '../../CustomMoveType';
-import { oncePerTurn } from '../../material/entity/Effect';
+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.remind(Memory.PendingEffects)[0];
-        if (pendingEffects.every((effect) => effect.auto)) {
+        const pendingEffects = this.getPendingEffects();
+        if (this.isAutoEffects()) {
             return [this.startRule(RuleId.ResolveEffects)];
         }
-        const cardIndex = pendingEffects[0].cardIndex;
-        const player = this.material(MaterialType.EntityCard).getItem(cardIndex).location.player;
-        return [this.startPlayerTurn(RuleId.ResolveEffects, player)];
+        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();
-        return moves.length === 1 ? moves : [];
+        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.remind(Memory.PendingEffects)[0] ?? [];
-        const autoEffect = pendingEffects.find((effect) => effect.auto);
-        if (autoEffect) {
-            return [this.customMove(CustomMoveType.PlayEffect, autoEffect)];
+        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));
         }
-        return pendingEffects.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) {
@@ -41,22 +102,23 @@ export class ResolveEffectsRule extends PlayerTurnRule {
         }
         return [];
     }
-    onPlayEffect(pendingEffect) {
-        const pendingEffects = this.remind(Memory.PendingEffects);
-        if (pendingEffects.length) {
-            pendingEffects[0] = pendingEffects[0].filter((effect) => !isEqual(effect, pendingEffect));
-            if (pendingEffects[0].length === 0) {
-                pendingEffects.splice(0, 1);
+    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(pendingEffect);
+        return this.playEffect(effect);
     }
-    playEffect(pendingEffect) {
-        this.memorize(Memory.OngoingEffect, pendingEffect);
-        const card = this.material(MaterialType.EntityCard).getItem(pendingEffect.cardIndex);
-        const effect = getEffects(card.id.front)[pendingEffect.effectIndex];
+    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(pendingEffect.cardIndex));
+            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)) {
@@ -66,7 +128,12 @@ export class ResolveEffectsRule extends PlayerTurnRule {
     }
     onEndEffect() {
         const moves = [];
-        this.forget(Memory.OngoingEffect);
+        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());
         }

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

@@ -6,5 +6,5 @@ export declare class SphinxEffectRule extends MoveEffectRule {
     getMovingCards(): Material;
     isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
     onCardMoved(move: MoveItem): import("@gamepark/rules-api").MaterialMove[];
-    updateGridAfterMoves(): MoveItem[];
+    updateGridAfterMoves(): void;
 }

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 { 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[]): PendingEffect[];
-    triggerCardEffect(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent): void;
-    getCardEffects(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent): PendingEffect[];
-    private getPlayersByEffectPriorityOrder;
+    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,5 +1,5 @@
 import { MaterialRulesPart } from '@gamepark/rules-api';
-import { isTriggeredEffect, TriggerEventType } from '../../material/entity/Effect';
+import { isTriggeredEffect, PendingEffectsType, TriggerEventType } from '../../material/entity/Effect';
 import { getEffects } from '../../material/entity/EntityDescription';
 import { MaterialType } from '../../material/MaterialType';
 import { Pantheon } from '../../material/Pantheon';
@@ -12,9 +12,9 @@ export class TriggerEffectsRule extends MaterialRulesPart {
         }
     }
     triggerPlayerEffects(player, ...triggerEvents) {
-        const pendingEffects = this.getPlayerEffects(player, ...triggerEvents);
-        if (pendingEffects.length) {
-            this.remind(Memory.PendingEffects).unshift(pendingEffects);
+        const effects = this.getPlayerEffects(player, ...triggerEvents);
+        if (effects.length) {
+            this.remind(Memory.PendingEffects).unshift({ type: PendingEffectsType.CardsEffects, player, effects });
         }
     }
     getPlayerEffects(player, ...triggerEvents) {
@@ -40,17 +40,17 @@ export class TriggerEffectsRule extends MaterialRulesPart {
         }
         return pendingEffects;
     }
-    triggerCardEffect(cardIndex, cardLocation, triggerEvent) {
-        const pendingEffects = this.getCardEffects(cardIndex, cardLocation, triggerEvent);
-        if (pendingEffects.length) {
-            this.remind(Memory.PendingEffects).unshift(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) {
+    getCardEffects(cardIndex, cardLocation, triggerEvent, entity = this.material(MaterialType.EntityCard).getItem(cardIndex).id.front) {
         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];
+        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 });
             }
@@ -58,7 +58,9 @@ export class TriggerEffectsRule extends MaterialRulesPart {
         return pendingEffects;
     }
     getPlayersByEffectPriorityOrder() {
-        const firstPlayer = this.game.rule?.player ?? this.material(MaterialType.FirstPlayerToken).getItem().location.player;
+        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/VishnuEffectRule.d.ts

@@ -0,0 +1,10 @@
+import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
+import { RuleId } from '../RuleId';
+export declare class VishnuEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    playEffect(): (import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").StartRule<RuleId>)[];
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): CustomMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+}

package/dist/rules/effects/VishnuEffectRule.js

@@ -0,0 +1,44 @@
+import { CustomMoveType } from '../../CustomMoveType';
+import { Destiny } from '../../material/Destiny';
+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 VishnuEffectRule extends PlayerEffectRule {
+    ruleId = RuleId.VishnuEffect;
+    playEffect() {
+        const godsToExile = new Destiny(this.game).cardsWithoutToken.location(LocationType.SanctuaryGodSpot);
+        if (!godsToExile.length)
+            return [];
+        this.memorize(Memory.TargetEntities, godsToExile.getIndexes());
+        const hiddenGods = godsToExile.rotation((rotation) => rotation !== undefined);
+        return [...hiddenGods.rotateItems(undefined), this.startRule(this.ruleId)];
+    }
+    onRuleStart() {
+        const moves = this.getPlayerMoves();
+        return moves.length === 1 ? moves : [];
+    }
+    getPlayerMoves() {
+        return this.remind(Memory.TargetEntities).map((entity) => this.customMove(CustomMoveType.ChooseEntityCard, entity));
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseEntityCard) {
+            const pantheon = new Pantheon(this.game, this.player);
+            const gods = this.material(MaterialType.EntityCard).index(this.remind(Memory.TargetEntities));
+            const entity = gods.getItem(move.data).id.front;
+            return [
+                ...gods.deleteItems(),
+                pantheon.gainFavor(gods.length),
+                ...pantheon.getInvokeGains(entity, this.card.location.y),
+                this.customMove(CustomMoveType.EndEffect)
+            ];
+        }
+        else if (move.type === CustomMoveType.EndEffect) {
+            this.forget(Memory.TargetEntities);
+            return this.onEndEffect();
+        }
+        return [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -25,8 +25,8 @@
     "es-toolkit": "^1.39.10"
   },
   "devDependencies": {
-    "@gamepark/rules-api": "~7.0.0",
+    "@gamepark/rules-api": "~7.0.3",
     "es-toolkit": "^1.39.10"
   },
-  "gitHead": "f7ebe2c5280cab7ff6adcbf520ccb564cbf7caf5"
+  "gitHead": "0c7452e2a5ab531208e1bc4d994ec47bfd7bfcdd"
 }