@gamepark/mythologies 0.3.1 → 0.4.1

package/dist/Memory.d.ts

@@ -13,5 +13,7 @@ export declare enum Memory {
     IllapaLine = 15,
     YanluoWangCount = 16,
     NuwaPlayerCreatures = 17,
-    TianlongVector = 18
+    TianlongVector = 18,
+    InkosazanaInvoke1 = 19,
+    FairyTargets = 20
 }

package/dist/Memory.js

@@ -18,4 +18,6 @@ var Memory;
     Memory[Memory["YanluoWangCount"] = 16] = "YanluoWangCount";
     Memory[Memory["NuwaPlayerCreatures"] = 17] = "NuwaPlayerCreatures";
     Memory[Memory["TianlongVector"] = 18] = "TianlongVector";
+    Memory[Memory["InkosazanaInvoke1"] = 19] = "InkosazanaInvoke1";
+    Memory[Memory["FairyTargets"] = 20] = "FairyTargets";
 })(Memory = exports.Memory || (exports.Memory = {}));

package/dist/MythologiesRules.d.ts

@@ -16,13 +16,17 @@ import { CobraEffectRule, CobraInvokeEffect } from './rules/effects/CobraEffectR
 import { CondorEffectRule } from './rules/effects/CondorEffectRule';
 import { CyclopsEffectRule } from './rules/effects/CyclopsEffectRule';
 import { DraugrEffectRule } from './rules/effects/DraugrEffectRule';
+import { FairyEffectRule } from './rules/effects/FairyEffectRule';
 import { FenghuangEffectRule } from './rules/effects/FenghuangEffectRule';
 import { FenrirChoiceRule, FenrirEffectRule } from './rules/effects/FenrirEffectRule';
 import { GarudaEffectRule } from './rules/effects/GarudaEffectRule';
 import { GorgonEffectRule } from './rules/effects/GorgonEffectRule';
 import { GriffinEffectRule } from './rules/effects/GriffinEffectRule';
 import { HadesEffectRule } from './rules/effects/HadesEffectRule';
+import { IdloziEffectRule } from './rules/effects/IdloziEffectRule';
 import { IllapaEffectRule, IllapaSacrificeRule } from './rules/effects/IllapaEffectRule';
+import { ImpunduluEffectRule } from './rules/effects/ImpunduluEffectRule';
+import { InkosazanaEffectRule } from './rules/effects/InkosazanaEffectRule';
 import { JiangshiEffectRule } from './rules/effects/JiangshiEffectRule';
 import { KinnaraEffectRule, KinnaraPlaceEffectRule } from './rules/effects/KinnaraEffectRule';
 import { MinotaurEffectRule } from './rules/effects/MinotaurEffectRule';
@@ -39,6 +43,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 { WerehyenaCallEffectRule, WerehyenaEffectRule } from './rules/effects/WerehyenaEffectRule';
 import { YanluoWangEffectRule } from './rules/effects/YanluoWangEffectRule';
 import { EndGameRule } from './rules/EndGameRule';
 import { PlaceCardsRule } from './rules/PlaceCardsRule';
@@ -95,6 +100,12 @@ export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, M
         50: typeof QilinEffectRule;
         51: typeof FenghuangEffectRule;
         52: typeof JiangshiEffectRule;
+        53: typeof InkosazanaEffectRule;
+        54: typeof ImpunduluEffectRule;
+        55: typeof WerehyenaEffectRule;
+        56: typeof WerehyenaCallEffectRule;
+        57: typeof IdloziEffectRule;
+        58: typeof FairyEffectRule;
     };
     locationsStrategies: {
         2: {

package/dist/MythologiesRules.js

@@ -39,13 +39,17 @@ var CobraEffectRule_1 = require("./rules/effects/CobraEffectRule");
 var CondorEffectRule_1 = require("./rules/effects/CondorEffectRule");
 var CyclopsEffectRule_1 = require("./rules/effects/CyclopsEffectRule");
 var DraugrEffectRule_1 = require("./rules/effects/DraugrEffectRule");
+var FairyEffectRule_1 = require("./rules/effects/FairyEffectRule");
 var FenghuangEffectRule_1 = require("./rules/effects/FenghuangEffectRule");
 var FenrirEffectRule_1 = require("./rules/effects/FenrirEffectRule");
 var GarudaEffectRule_1 = require("./rules/effects/GarudaEffectRule");
 var GorgonEffectRule_1 = require("./rules/effects/GorgonEffectRule");
 var GriffinEffectRule_1 = require("./rules/effects/GriffinEffectRule");
 var HadesEffectRule_1 = require("./rules/effects/HadesEffectRule");
+var IdloziEffectRule_1 = require("./rules/effects/IdloziEffectRule");
 var IllapaEffectRule_1 = require("./rules/effects/IllapaEffectRule");
+var ImpunduluEffectRule_1 = require("./rules/effects/ImpunduluEffectRule");
+var InkosazanaEffectRule_1 = require("./rules/effects/InkosazanaEffectRule");
 var JiangshiEffectRule_1 = require("./rules/effects/JiangshiEffectRule");
 var KinnaraEffectRule_1 = require("./rules/effects/KinnaraEffectRule");
 var MinotaurEffectRule_1 = require("./rules/effects/MinotaurEffectRule");
@@ -63,6 +67,7 @@ var TriggerEffectsRule_1 = require("./rules/effects/TriggerEffectsRule");
 var UkukuEffectRule_1 = require("./rules/effects/UkukuEffectRule");
 var VetalaEffectRule_1 = require("./rules/effects/VetalaEffectRule");
 var ViracochaEffectRule_1 = require("./rules/effects/ViracochaEffectRule");
+var WerehyenaEffectRule_1 = require("./rules/effects/WerehyenaEffectRule");
 var YanluoWangEffectRule_1 = require("./rules/effects/YanluoWangEffectRule");
 var EndGameRule_1 = require("./rules/EndGameRule");
 var PlaceCardsRule_1 = require("./rules/PlaceCardsRule");
@@ -124,6 +129,12 @@ var MythologiesRules = (function (_super) {
             _a[RuleId_1.RuleId.QilinEffect] = QilinEffectRule_1.QilinEffectRule,
             _a[RuleId_1.RuleId.FenghuangEffect] = FenghuangEffectRule_1.FenghuangEffectRule,
             _a[RuleId_1.RuleId.JiangshiEffect] = JiangshiEffectRule_1.JiangshiEffectRule,
+            _a[RuleId_1.RuleId.InkosazanaEffect] = InkosazanaEffectRule_1.InkosazanaEffectRule,
+            _a[RuleId_1.RuleId.ImpunduluEffect] = ImpunduluEffectRule_1.ImpunduluEffectRule,
+            _a[RuleId_1.RuleId.WerehyenaEffect] = WerehyenaEffectRule_1.WerehyenaEffectRule,
+            _a[RuleId_1.RuleId.WerehyenaCallEffect] = WerehyenaEffectRule_1.WerehyenaCallEffectRule,
+            _a[RuleId_1.RuleId.IdloziEffect] = IdloziEffectRule_1.IdloziEffectRule,
+            _a[RuleId_1.RuleId.FairyEffect] = FairyEffectRule_1.FairyEffectRule,
             _a);
         _this.locationsStrategies = (_b = {},
             _b[MaterialType_1.MaterialType.EntityCard] = (_c = {},

package/dist/material/Destiny.d.ts

@@ -4,6 +4,7 @@ export declare class Destiny extends MaterialRulesPart {
     getMythologyBoard(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
     getMythology(player: PlayerColor): import("./Mythology").Mythology;
     getDestinyMap(destiny: number): PlayerColor[][];
+    get cardsWithoutToken(): import("@gamepark/rules-api").Material<number, number, number>;
     getAvailableEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
     getBoardsWithoutPlayer(): import("@gamepark/rules-api").Material<number, number, number>;
     get creaturesOnTopOfDecks(): import("@gamepark/rules-api").Material<number, number, number>;

package/dist/material/Destiny.js

@@ -64,14 +64,18 @@ var Destiny = (function (_super) {
                 throw new Error("Unknown destiny card: ".concat(destiny));
         }
     };
+    Object.defineProperty(Destiny.prototype, "cardsWithoutToken", {
+        get: function () {
+            var tokensOnCards = this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.OnEntityCard).getItems();
+            var cardsWithToken = tokensOnCards.map(function (item) { return item.location.parent; });
+            return this.material(MaterialType_1.MaterialType.EntityCard).index(function (index) { return !cardsWithToken.includes(index); });
+        },
+        enumerable: false,
+        configurable: true
+    });
     Destiny.prototype.getAvailableEntities = function (player) {
-        var tokensOnCards = this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.OnEntityCard).getItems();
-        var cardsWithToken = tokensOnCards.map(function (item) { return item.location.parent; });
         var mythology = this.getMythologyBoard(player).getIndex();
-        return this.material(MaterialType_1.MaterialType.EntityCard)
-            .location(function (l) { return l.type === LocationType_1.LocationType.SanctuaryGodSpot || l.type === LocationType_1.LocationType.SanctuaryCreatureSpot; })
-            .parent(mythology)
-            .index(function (index) { return !cardsWithToken.includes(index); });
+        return this.cardsWithoutToken.location(function (l) { return l.type === LocationType_1.LocationType.SanctuaryGodSpot || l.type === LocationType_1.LocationType.SanctuaryCreatureSpot; }).parent(mythology);
     };
     Destiny.prototype.getBoardsWithoutPlayer = function () {
         var _this = this;

package/dist/material/Entity.d.ts

@@ -1,3 +1,6 @@
+import { MaterialItem } from '../../../../rules-api';
+import { PlayerColor } from '../PlayerColor';
+import { LocationType } from './LocationType';
 import { Mythology } from './Mythology';
 export declare enum Entity {
     Zeus = 1,
@@ -76,7 +79,7 @@ export declare enum Entity {
     Morrigan = 74,
     Kelpie = 75,
     Banshee = 76,
-    Dryad = 77,
+    Fairy = 77,
     Leprechaun = 78,
     Selkie = 79,
     Dullahan = 80
@@ -92,6 +95,7 @@ export type EntityId = {
         entityType: EntityType;
     };
 };
+export type EntityItem = MaterialItem<PlayerColor, LocationType, EntityId>;
 export declare const getEntityType: (entity: Entity) => EntityType;
 export declare const isGod: (entity?: Entity) => boolean;
 export declare const isCreature: (entity?: Entity) => boolean;

package/dist/material/Entity.js

@@ -79,7 +79,7 @@ var Entity;
     Entity[Entity["Morrigan"] = 74] = "Morrigan";
     Entity[Entity["Kelpie"] = 75] = "Kelpie";
     Entity[Entity["Banshee"] = 76] = "Banshee";
-    Entity[Entity["Dryad"] = 77] = "Dryad";
+    Entity[Entity["Fairy"] = 77] = "Fairy";
     Entity[Entity["Leprechaun"] = 78] = "Leprechaun";
     Entity[Entity["Selkie"] = 79] = "Selkie";
     Entity[Entity["Dullahan"] = 80] = "Dullahan";

package/dist/material/Mythology.js

@@ -13,7 +13,7 @@ var Mythology;
     Mythology[Mythology["Zulu"] = 6] = "Zulu";
     Mythology[Mythology["Celtic"] = 7] = "Celtic";
 })(Mythology = exports.Mythology || (exports.Mythology = {}));
-exports.availableMythologies = (0, rules_api_1.getEnumValues)(Mythology).filter(function (mythology) { return mythology < 6; });
+exports.availableMythologies = (0, rules_api_1.getEnumValues)(Mythology).filter(function (mythology) { return mythology < 7; });
 var SanctuarySide;
 (function (SanctuarySide) {
     SanctuarySide[SanctuarySide["Left"] = 0] = "Left";

package/dist/material/Pantheon.d.ts

@@ -1,6 +1,7 @@
 import { Material, MaterialGame, MaterialItem, MaterialMove, MaterialRulesPart, MoveItem, XYCoordinates } from '@gamepark/rules-api';
 import { PlayerColor } from '../PlayerColor';
-import { Entity } from './Entity';
+import { Entity, EntityItem } from './Entity';
+import { TriggerEvent } from './entity/Effect';
 export declare class Pantheon extends MaterialRulesPart {
     private player;
     constructor(game: MaterialGame, player: PlayerColor);
@@ -11,7 +12,7 @@ export declare class Pantheon extends MaterialRulesPart {
     private get indexGrid();
     get legalSpacesToInvoke(): XYCoordinates[];
     isLegalSpaceToInvoke(space: XYCoordinates): boolean;
-    getOpponentsWithTrollAt({ x, y }: XYCoordinates): PlayerColor[];
+    getFavorTax(space: XYCoordinates): number;
     get legalSpaces(): XYCoordinates[];
     isLegalSpace({ x, y }: XYCoordinates, grid?: (Entity | undefined)[][]): boolean;
     isFreeSpace({ x, y }: XYCoordinates): boolean;
@@ -24,9 +25,10 @@ export declare class Pantheon extends MaterialRulesPart {
     loseFavor(quantity?: number): import("@gamepark/rules-api").DeleteItem<number>;
     onCardPlaced(move: MoveItem): MaterialMove<number, number, number, number>[];
     get isInvoke(): boolean;
-    updateGrid(gridAfter?: (number | null)[][]): MaterialMove<number, number, number, number>[];
-    private entityMoved;
-    private gainBonus;
+    updateGrid(gridAfter?: (number | null)[][]): TriggerEvent[];
+    private getEntitiesMoved;
+    private getEntitiesCrushed;
+    gainBonus(grid?: (number | null)[][]): MaterialMove<number, number, number, number>[];
     gainLineBonus(y: number): MoveItem<number, number, number>[];
     gainColumnBonus(x: number): MoveItem<number, number, number>[];
     getBonusGem(y: number): Material<number, number, number>;
@@ -35,9 +37,11 @@ export declare class Pantheon extends MaterialRulesPart {
     getInvokeGains(entity: Entity, line: number): MaterialMove<number, number, number, number>[];
     hasEntity(entity: Entity): boolean;
     getPiles(predicate?: (space: XYCoordinates) => boolean): Material[];
-    isAbleToMove(entity: MaterialItem): boolean;
+    isAbleToMove(entity: EntityItem): boolean;
     get mythologies(): import("./Mythology").Mythology[];
     get missingMythologies(): import("./Mythology").Mythology[];
-    onEntitySacrificed(card: Material): MaterialMove<number, number, number, number>[];
+    onEntitySacrificed(card: Material): void;
     hasCrushed(card: MaterialItem): boolean;
+    isOpponentOngoingEffect(): boolean;
+    replaceSacrifice(cards: EntityItem[]): Material<number, number, number>;
 }

package/dist/material/Pantheon.js

@@ -56,6 +56,7 @@ var rules_api_1 = require("@gamepark/rules-api");
 var lodash_1 = require("lodash");
 var Memory_1 = require("../Memory");
 var MythologiesRules_1 = require("../MythologiesRules");
+var PermanentEffectsRule_1 = require("../rules/effects/PermanentEffectsRule");
 var TriggerEffectsRule_1 = require("../rules/effects/TriggerEffectsRule");
 var Entity_1 = require("./Entity");
 var Effect_1 = require("./entity/Effect");
@@ -92,7 +93,7 @@ var Pantheon = (function (_super) {
             var allCards = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.Pantheon).player(this.player);
             return allCards.location(function (_a) {
                 var x = _a.x, y = _a.y, z = _a.z;
-                return z < allCards.location(function (l) { return l.x === x && l.y === y; }).length;
+                return z < allCards.location(function (l) { return l.x === x && l.y === y; }).length - 1;
             });
         },
         enumerable: false,
@@ -128,16 +129,14 @@ var Pantheon = (function (_super) {
         configurable: true
     });
     Pantheon.prototype.isLegalSpaceToInvoke = function (space) {
-        var trollOpponents = this.getOpponentsWithTrollAt(space);
-        return !trollOpponents.length || this.favor >= trollOpponents.length;
-    };
-    Pantheon.prototype.getOpponentsWithTrollAt = function (_a) {
         var _this = this;
-        var x = _a.x, y = _a.y;
-        return this.game.players.filter(function (player) {
-            if (player === _this.player)
-                return false;
-            return new Pantheon(_this.game, player).grid[y][x] === Entity_1.Entity.Troll;
+        var opponents = this.game.players.filter(function (player) { return player !== _this.player; });
+        var favorTax = (0, lodash_1.sumBy)(opponents, function (opponent) { return new Pantheon(_this.game, opponent).getFavorTax(space); });
+        return this.favor >= favorTax;
+    };
+    Pantheon.prototype.getFavorTax = function (space) {
+        return (0, lodash_1.sumBy)(this.visibleEntities.getItems(), function (card) {
+            return (0, lodash_1.sumBy)((0, EntityDescription_1.getEffects)(card.id.front), function (effect) { var _a, _b, _c; return (_c = (_b = (_a = effect).favorTax) === null || _b === void 0 ? void 0 : _b.call(_a, space, card)) !== null && _c !== void 0 ? _c : 0; });
         });
     };
     Object.defineProperty(Pantheon.prototype, "legalSpaces", {
@@ -154,7 +153,8 @@ var Pantheon = (function (_super) {
     Pantheon.prototype.isLegalSpace = function (_a, grid) {
         var x = _a.x, y = _a.y;
         if (grid === void 0) { grid = this.grid; }
-        return !(0, Entity_1.isGod)(grid[y][x]);
+        var card = this.visibleEntities.location(function (l) { return l.x === x && l.y === y; }).getItem();
+        return !card || (!(0, Entity_1.isGod)(grid[y][x]) && new PermanentEffectsRule_1.PermanentEffectsRule(this.game).canCrush(card));
     };
     Pantheon.prototype.isFreeSpace = function (_a) {
         var x = _a.x, y = _a.y;
@@ -206,21 +206,14 @@ var Pantheon = (function (_super) {
         }
         var grid = this.indexGrid;
         grid[move.location.y][move.location.x] = move.itemIndex;
-        moves.push.apply(moves, __spreadArray([], __read(this.updateGrid(grid)), false));
+        moves.push.apply(moves, __spreadArray([], __read(this.gainBonus(grid)), false));
         var triggerEffectsRule = new TriggerEffectsRule_1.TriggerEffectsRule(this.game);
-        var crushed = this.allCards.location(function (l) { return l.x === move.location.x && l.y === move.location.y; }).maxBy(function (item) { return item.location.z; });
         triggerEffectsRule.triggerCardEffect(card, { type: Effect_1.TriggerEventType.SelfPlaced, location: location });
-        var invoke = this.isInvoke;
-        if (invoke) {
+        var triggerEvents = this.updateGrid(grid);
+        if (this.isInvoke) {
             moves.push.apply(moves, __spreadArray([], __read(this.onInvoke(move)), false));
-        }
-        var triggerEvents = [];
-        if (invoke) {
             triggerEvents.push({ type: Effect_1.TriggerEventType.EntityInvoked, cardIndex: move.itemIndex, entity: entity, cardLocation: location });
         }
-        if (crushed.length) {
-            triggerEvents.push({ type: Effect_1.TriggerEventType.EntityCrushed, card: crushed.getItem(), cardIndex: crushed.getIndex() });
-        }
         if (triggerEvents.length) {
             triggerEffectsRule.triggerEffects.apply(triggerEffectsRule, __spreadArray([], __read(triggerEvents), false));
         }
@@ -234,47 +227,80 @@ var Pantheon = (function (_super) {
         configurable: true
     });
     Pantheon.prototype.updateGrid = function (gridAfter) {
-        var _a;
+        var e_1, _a;
+        var _b;
         if (gridAfter === void 0) { gridAfter = this.indexGrid; }
-        var gridBefore = (_a = this.remind(Memory_1.Memory.PlayerGrid, this.player)) !== null && _a !== void 0 ? _a : this.indexGrid;
+        var gridBefore = (_b = this.remind(Memory_1.Memory.PlayerGrid, this.player)) !== null && _b !== void 0 ? _b : this.indexGrid;
         this.memorize(Memory_1.Memory.PlayerGrid, gridAfter, this.player);
-        if (this.entityMoved(gridBefore, gridAfter)) {
-            new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.EntityMoved, player: this.player });
+        var triggerEvents = [];
+        var entitiesMoved = this.getEntitiesMoved(gridBefore, gridAfter);
+        if (entitiesMoved.length) {
+            triggerEvents.push({ type: Effect_1.TriggerEventType.EntitiesMoved, player: this.player, entities: entitiesMoved });
+        }
+        var entitiesCrushed = this.getEntitiesCrushed(gridBefore, gridAfter);
+        try {
+            for (var entitiesCrushed_1 = __values(entitiesCrushed), entitiesCrushed_1_1 = entitiesCrushed_1.next(); !entitiesCrushed_1_1.done; entitiesCrushed_1_1 = entitiesCrushed_1.next()) {
+                var cardIndex = entitiesCrushed_1_1.value;
+                triggerEvents.push({ type: Effect_1.TriggerEventType.EntityCrushed, card: this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex), cardIndex: cardIndex });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (entitiesCrushed_1_1 && !entitiesCrushed_1_1.done && (_a = entitiesCrushed_1.return)) _a.call(entitiesCrushed_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         for (var y = 0; y < 3; y++) {
             if (gridBefore[y].some(function (item) { return item === null; }) && gridAfter[y].every(function (item) { return item !== null; })) {
-                new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.LineEvent, eventType: Effect_1.LineEventType.Completed, player: this.player, y: y });
+                triggerEvents.push({ type: Effect_1.TriggerEventType.LineEvent, eventType: Effect_1.LineEventType.Completed, player: this.player, y: y });
             }
         }
         var _loop_1 = function (x) {
             if (gridBefore.some(function (line) { return line[x] === null; }) && gridAfter.every(function (line) { return line[x] !== null; })) {
-                new TriggerEffectsRule_1.TriggerEffectsRule(this_1.game).triggerEffects({ type: Effect_1.TriggerEventType.ColumnEvent, eventType: Effect_1.LineEventType.Completed, player: this_1.player, x: x });
+                triggerEvents.push({ type: Effect_1.TriggerEventType.ColumnEvent, eventType: Effect_1.LineEventType.Completed, player: this_1.player, x: x });
             }
         };
         var this_1 = this;
         for (var x = 0; x < 3; x++) {
             _loop_1(x);
         }
-        return this.gainBonus(gridAfter);
+        return triggerEvents;
     };
-    Pantheon.prototype.entityMoved = function (before, after) {
+    Pantheon.prototype.getEntitiesMoved = function (before, after) {
+        var entities = [];
         for (var y = 0; y < 3; y++) {
             var _loop_2 = function (x) {
                 var cardIndex = before[y][x];
                 if (cardIndex !== null && cardIndex !== after[y][x] && after.some(function (line) { return line.includes(cardIndex); })) {
-                    return { value: true };
+                    entities.push(cardIndex);
                 }
             };
             for (var x = 0; x < 3; x++) {
-                var state_1 = _loop_2(x);
-                if (typeof state_1 === "object")
-                    return state_1.value;
+                _loop_2(x);
             }
         }
-        return false;
+        return entities;
+    };
+    Pantheon.prototype.getEntitiesCrushed = function (before, after) {
+        var entities = [];
+        var allCardsIndexes = this.allCards.getIndexes();
+        for (var y = 0; y < 3; y++) {
+            var _loop_3 = function (x) {
+                var cardIndex = before[y][x];
+                if (cardIndex !== null && !after.some(function (line) { return line.includes(cardIndex); }) && allCardsIndexes.includes(cardIndex)) {
+                    entities.push(cardIndex);
+                }
+            };
+            for (var x = 0; x < 3; x++) {
+                _loop_3(x);
+            }
+        }
+        return entities;
     };
     Pantheon.prototype.gainBonus = function (grid) {
-        var e_1, _a, e_2, _b;
+        var e_2, _a, e_3, _b;
+        if (grid === void 0) { grid = this.indexGrid; }
         var moves = [];
         var fullLines = (0, lodash_1.range)(0, 3).filter(function (y) { return !grid[y].includes(null); });
         try {
@@ -283,12 +309,12 @@ var Pantheon = (function (_super) {
                 moves.push.apply(moves, __spreadArray([], __read(this.gainLineBonus(y)), false));
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
                 if (fullLines_1_1 && !fullLines_1_1.done && (_a = fullLines_1.return)) _a.call(fullLines_1);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_2) throw e_2.error; }
         }
         var fullColumns = (0, lodash_1.range)(0, 3).filter(function (x) { return grid.every(function (line) { return line[x] !== null; }); });
         try {
@@ -297,12 +323,12 @@ var Pantheon = (function (_super) {
                 moves.push.apply(moves, __spreadArray([], __read(this.gainColumnBonus(x)), false));
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (fullColumns_1_1 && !fullColumns_1_1.done && (_b = fullColumns_1.return)) _b.call(fullColumns_1);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         return moves;
     };
@@ -327,26 +353,30 @@ var Pantheon = (function (_super) {
             .location(function (l) { return l.x === x; });
     };
     Pantheon.prototype.onInvoke = function (move) {
-        var e_3, _a;
+        var e_4, _a;
         var moves = [];
         var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex).getItem();
         var entity = card.id.front;
         if (!entity)
             return [];
-        var trollOpponents = this.getOpponentsWithTrollAt(move.location);
         var favor = this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(this.player);
         try {
-            for (var trollOpponents_1 = __values(trollOpponents), trollOpponents_1_1 = trollOpponents_1.next(); !trollOpponents_1_1.done; trollOpponents_1_1 = trollOpponents_1.next()) {
-                var trollOpponent = trollOpponents_1_1.value;
-                moves.push(favor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: trollOpponent }));
+            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                if (player !== this.player) {
+                    var favorTax = new Pantheon(this.game, player).getFavorTax(move.location);
+                    if (favorTax > 0) {
+                        moves.push(favor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: player }, favorTax));
+                    }
+                }
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
-                if (trollOpponents_1_1 && !trollOpponents_1_1.done && (_a = trollOpponents_1.return)) _a.call(trollOpponents_1);
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_4) throw e_4.error; }
         }
         moves.push.apply(moves, __spreadArray([], __read(this.getInvokeGains(entity, move.location.y)), false));
         return moves;
@@ -370,8 +400,8 @@ var Pantheon = (function (_super) {
         var piles = [];
         var myEntities = this.material(MaterialType_1.MaterialType.EntityCard).player(this.player);
         var fullPantheon = myEntities.location(LocationType_1.LocationType.Pantheon);
-        var _loop_3 = function (x) {
-            var _loop_4 = function (y) {
+        var _loop_4 = function (x) {
+            var _loop_5 = function (y) {
                 if (predicate({ x: x, y: y })) {
                     var pile = fullPantheon.location(function (l) { return l.x === x && l.y === y; }).sort(function (item) { return item.location.z; });
                     if (pile.length > 0) {
@@ -380,16 +410,16 @@ var Pantheon = (function (_super) {
                 }
             };
             for (var y = 0; y < 3; y++) {
-                _loop_4(y);
+                _loop_5(y);
             }
         };
         for (var x = 0; x < 3; x++) {
-            _loop_3(x);
+            _loop_4(x);
         }
         return piles;
     };
     Pantheon.prototype.isAbleToMove = function (entity) {
-        return !this.visibleEntities.getItems().some(function (item) { return item.id.front === Entity_1.Entity.Naga && (0, rules_api_1.areAdjacentSquares)(item.location, entity.location); });
+        return new PermanentEffectsRule_1.PermanentEffectsRule(this.game).canMove(entity);
     };
     Object.defineProperty(Pantheon.prototype, "mythologies", {
         get: function () {
@@ -409,12 +439,26 @@ var Pantheon = (function (_super) {
         configurable: true
     });
     Pantheon.prototype.onEntitySacrificed = function (card) {
-        new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.EntitySacrificed, card: card.getItem(), cardIndex: card.getIndex() });
-        return this.updateGrid();
+        var _a;
+        var effects = this.updateGrid();
+        effects.push({ type: Effect_1.TriggerEventType.EntitySacrificed, card: card.getItem(), cardIndex: card.getIndex() });
+        (_a = new TriggerEffectsRule_1.TriggerEffectsRule(this.game)).triggerEffects.apply(_a, __spreadArray([], __read(effects), false));
     };
     Pantheon.prototype.hasCrushed = function (card) {
         return this.allCards.location(function (l) { return l.x === card.location.x && l.y === card.location.y && l.z < card.location.z; }).length > 0;
     };
+    Pantheon.prototype.isOpponentOngoingEffect = function () {
+        var ongoingEffect = this.remind(Memory_1.Memory.OngoingEffect);
+        if (!ongoingEffect)
+            return false;
+        var effectOwner = this.material(MaterialType_1.MaterialType.EntityCard).getItem(ongoingEffect.cardIndex).location.player;
+        return this.player !== effectOwner;
+    };
+    Pantheon.prototype.replaceSacrifice = function (cards) {
+        return this.visibleEntities.filter(function (item) {
+            return (0, EntityDescription_1.getEffects)(item.id.front).some(function (effect) { return !(0, Effect_1.isTriggeredEffect)(effect) && cards.some(function (card) { var _a; return (_a = effect.replaceSacrifice) === null || _a === void 0 ? void 0 : _a.call(effect, card, item); }); });
+        });
+    };
     return Pantheon;
 }(rules_api_1.MaterialRulesPart));
 exports.Pantheon = Pantheon;

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

@@ -1,14 +1,21 @@
-import { Location, Material, MaterialGame, MaterialItem, MaterialMove, MaterialRulesPart, PlayerTurnRule, SimultaneousRule } from '@gamepark/rules-api';
+import { Location, Material, MaterialGame, MaterialMove, MaterialRulesPart, PlayerTurnRule, SimultaneousRule, XYCoordinates } from '@gamepark/rules-api';
 import { PlayerColor } from '../../PlayerColor';
 import { RuleId } from '../../rules/RuleId';
-import { Entity, EntityId } from '../Entity';
-import { LocationType } from '../LocationType';
-import { MaterialType } from '../MaterialType';
-export type Effect = {
+import { Entity, EntityId, EntityItem } from '../Entity';
+export type TriggeredEffect = {
     trigger: (event: TriggerEvent, card: Material, game: MaterialGame) => boolean;
     rule: new (game: MaterialGame) => EffectRule;
     auto?: boolean;
 };
+export declare const isTriggeredEffect: (effect: Effect) => effect is TriggeredEffect;
+export type PermanentEffect = {
+    preventSacrifice?: (card: EntityItem, effectCard: EntityItem) => boolean;
+    preventMove?: (card: EntityItem, effectCard: EntityItem) => boolean;
+    preventCrush?: (card: EntityItem, effectCard: EntityItem) => boolean;
+    replaceSacrifice?: (card: EntityItem, effectCard: EntityItem) => boolean;
+    favorTax?: (space: XYCoordinates, card: EntityItem) => number;
+};
+export type Effect = TriggeredEffect | PermanentEffect;
 interface EffectRule {
     canPlayEffect(cardIndex: number): boolean;
     playEffect(): MaterialMove[];
@@ -18,7 +25,7 @@ export declare abstract class PlayerEffectRule extends PlayerTurnRule implements
     ruleId?: RuleId;
     playEffect(): MaterialMove[];
     onRuleStart(): MaterialMove<number, number, number, number>[];
-    get card(): MaterialItem<number, number, EntityId>;
+    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
     getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
     endEffect(): MaterialMove[];
 }
@@ -28,7 +35,7 @@ export declare abstract class SimultaneousEffectRule extends SimultaneousRule im
     playEffect(): MaterialMove[];
     getAffectedPlayers(): PlayerColor[];
     isOpponent(player: PlayerColor): boolean;
-    get card(): MaterialItem<number, number, EntityId>;
+    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
     getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
     getMovesAfterPlayersDone(): MaterialMove[];
 }
@@ -36,7 +43,7 @@ export declare abstract class AutoEffectRule extends MaterialRulesPart implement
     canPlayEffect: () => boolean;
     abstract playEffect(): MaterialMove[];
     getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
-    get card(): MaterialItem<number, number, EntityId>;
+    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
     get player(): PlayerColor;
 }
 export declare enum TriggerEventType {
@@ -48,7 +55,8 @@ export declare enum TriggerEventType {
     Infinite = 6,
     EntityCrushed = 7,
     EntitySacrificed = 8,
-    EntityMoved = 9
+    EntitiesMoved = 9,
+    EndOfTurn = 10
 }
 export type SelfPlaced = {
     type: TriggerEventType.SelfPlaced;
@@ -87,23 +95,30 @@ export type Infinite = {
 export declare const oncePerTurn: (event: TriggerEvent) => event is Infinite;
 export type EntityCrushed = {
     type: TriggerEventType.EntityCrushed;
-    card: MaterialItem<MaterialType, LocationType, EntityId>;
+    card: EntityItem;
     cardIndex: number;
 };
 export declare const isCrushed: (event: TriggerEvent, card: Material) => event is EntityCrushed;
 export type EntitySacrificed = {
     type: TriggerEventType.EntitySacrificed;
-    card: MaterialItem<MaterialType, LocationType, EntityId>;
+    card: EntityItem;
     cardIndex: number;
 };
 export declare const isSacrificed: (event: TriggerEvent, card: Material) => event is EntityCrushed;
-export type EntityMoved = {
-    type: TriggerEventType.EntityMoved;
+export type EntitiesMoved = {
+    type: TriggerEventType.EntitiesMoved;
+    player: PlayerColor;
+    entities: number[];
+};
+export type EndOfTurn = {
+    type: TriggerEventType.EndOfTurn;
     player: PlayerColor;
 };
-export type TriggerEvent = EndOfGameEvent | SelfPlaced | EntityInvoked | LineEvent | ColumnEvent | Infinite | EntityCrushed | EntitySacrificed | EntityMoved;
+export declare const isEndOfMyTurn: (event: TriggerEvent, card: Material) => event is EndOfTurn;
+export type TriggerEvent = EndOfGameEvent | SelfPlaced | EntityInvoked | LineEvent | ColumnEvent | Infinite | EntityCrushed | EntitySacrificed | EntitiesMoved | EndOfTurn;
 export type PendingEffect<Event extends TriggerEvent = TriggerEvent> = {
     cardIndex: number;
+    effectIndex: number;
     triggerEvent: Event;
     auto: boolean;
 };