@gamepark/mythologies 1.0.2 → 1.0.4

package/dist/material/Pantheon.d.ts

@@ -10,8 +10,8 @@ export declare class Pantheon extends MaterialRulesPart {
     get coveredEntities(): Material<number, number, number>;
     get grid(): (Entity | undefined)[][];
     private get indexGrid();
-    get legalSpacesToSummon(): XYCoordinates[];
-    isLegalSpaceToSummon(space: XYCoordinates): boolean;
+    getLegalSpacesToSummon(entity: Entity): XYCoordinates[];
+    isLegalSpaceToSummon(space: XYCoordinates, entity?: Entity): boolean;
     getFavorTax(space: XYCoordinates): number;
     getGemTax(space: XYCoordinates): number;
     get legalSpaces(): XYCoordinates[];

package/dist/material/Pantheon.js

@@ -38,14 +38,15 @@ export class Pantheon extends MaterialRulesPart {
             return entity.length > 0 ? entity.getIndex() : null;
         }));
     }
-    get legalSpacesToSummon() {
-        return this.legalSpaces.filter((space) => this.isLegalSpaceToSummon(space));
+    getLegalSpacesToSummon(entity) {
+        return this.legalSpaces.filter((space) => this.isLegalSpaceToSummon(space, entity));
     }
-    isLegalSpaceToSummon(space) {
+    isLegalSpaceToSummon(space, entity) {
         const opponents = this.game.players.filter((player) => player !== this.player);
         const favorTax = sumBy(opponents, (opponent) => new Pantheon(this.game, opponent).getFavorTax(space));
         const gemTax = sumBy(opponents, (opponent) => new Pantheon(this.game, opponent).getGemTax(space));
-        return (!favorTax || this.favor >= favorTax) && (!gemTax || this.gems >= gemTax);
+        const totalGemCost = gemTax + (isGod(entity) ? 4 : 0);
+        return (!favorTax || this.favor >= favorTax) && (!totalGemCost || this.gems >= totalGemCost);
     }
     getFavorTax(space) {
         return sumBy(this.visibleEntities.getItems(), (card) => sumBy(getEffects(card.id.front), (effect) => effect.favorTax?.(space, card) ?? 0));
@@ -217,7 +218,7 @@ export class Pantheon extends MaterialRulesPart {
                 const gemTax = new Pantheon(this.game, player).getGemTax(move.location);
                 if (gemTax > 0) {
                     const gems = this.material(MaterialType.GemToken).location(LocationType.PlayerGems).player(this.player);
-                    moves.push(gems.moveItem({ type: LocationType.PlayerFavor, player }, gemTax));
+                    moves.push(gems.moveItem({ type: LocationType.PlayerGems, player }, gemTax));
                 }
             }
         }

package/dist/material/Trial.js

@@ -119,7 +119,6 @@ export class Trial extends MaterialRulesPart {
     getTrialLeftReward(mythology) {
         switch (mythology) {
             case Mythology.Greek:
-            case Mythology.Norse:
             case Mythology.Egyptian:
             case Mythology.Inca:
                 return 1;

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

@@ -13,5 +13,4 @@ export declare abstract class PlaceCardEffectRule extends PlayerEffectRule {
 }
 export declare abstract class SummonEffectRule extends PlaceCardEffectRule {
     isSummon: boolean;
-    getAvailableDestinations(): XYCoordinates[];
 }

package/dist/material/entity/PlaceCardEffectRule.js

@@ -1,7 +1,6 @@
 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';
@@ -32,8 +31,11 @@ export class PlaceCardEffectRule extends PlayerEffectRule {
     getPlayerMoves(cardIndex = this.getEffect().cardIndex) {
         const player = this.material(MaterialType.EntityCard).getItem(cardIndex).location.player;
         const cards = this.getCardsToPlace(cardIndex);
-        const cardsICanPlace = new Pantheon(this.game, player).gems < 4 ? cards.id((id) => !isGod(id.front)) : cards;
-        return this.getAvailableDestinations(cardIndex).flatMap(({ x, y }) => cardsICanPlace.moveItems({ type: LocationType.Pantheon, player, x, y }));
+        const pantheon = new Pantheon(this.game, player);
+        return this.getAvailableDestinations(cardIndex).flatMap(({ x, y }) => {
+            const cardsICanPlace = cards.id((id) => pantheon.isLegalSpaceToSummon({ x, y }, id.front));
+            return cardsICanPlace.moveItems({ type: LocationType.Pantheon, player, x, y });
+        });
     }
     getAvailableDestinations(_cardIndex) {
         return new Pantheon(this.game, this.player).legalSpaces;
@@ -52,7 +54,4 @@ export class PlaceCardEffectRule extends PlayerEffectRule {
 }
 export class SummonEffectRule extends PlaceCardEffectRule {
     isSummon = true;
-    getAvailableDestinations() {
-        return new Pantheon(this.game, this.player).legalSpacesToSummon;
-    }
 }

package/dist/rules/PlaceCardsRule.js

@@ -1,6 +1,5 @@
 import { isMoveItemType, PlayerTurnRule } from '@gamepark/rules-api';
 import { CustomMoveType } from '../CustomMoveType';
-import { isGod } from '../material/Entity';
 import { isTriggeredEffect, TriggerEventType } from '../material/entity/Effect';
 import { getEffects } from '../material/entity/EntityDescription';
 import { LocationType } from '../material/LocationType';
@@ -17,8 +16,9 @@ export class PlaceCardsRule extends PlayerTurnRule {
         const moves = this.infiniteEffects.map((effect) => this.customMove(CustomMoveType.PlayEffect, effect));
         const cards = this.material(MaterialType.EntityCard).location(LocationType.PlayerSelectedCards).player(this.player);
         if (cards.length) {
-            const cardsICanSummon = new Pantheon(this.game, this.player).gems < 4 ? cards.id((id) => !isGod(id.front)) : cards;
-            for (const { x, y } of new Pantheon(this.game, this.player).legalSpacesToSummon) {
+            const pantheon = new Pantheon(this.game, this.player);
+            for (const { x, y } of pantheon.legalSpaces) {
+                const cardsICanSummon = cards.id((id) => pantheon.isLegalSpaceToSummon({ x, y }, id.front));
                 moves.push(...cardsICanSummon.moveItems({ type: LocationType.Pantheon, x, y, player: this.player }));
             }
             moves.push(...cards.moveItems({ type: LocationType.PlayerDiscard, player: this.player }));

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

@@ -5,5 +5,5 @@ export declare class AnubisEffectRule extends SummonEffectRule {
     ruleId: RuleId;
     times: number;
     getCardsToPlace(): Material;
-    getAvailableDestinations(): import("@gamepark/rules-api").XYCoordinates[];
+    getAvailableDestinations(cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
 }

package/dist/rules/effects/AnubisEffectRule.js

@@ -8,7 +8,7 @@ export class AnubisEffectRule extends SummonEffectRule {
     getCardsToPlace() {
         return this.material(MaterialType.EntityCard).location(LocationType.PlayerDiscard);
     }
-    getAvailableDestinations() {
-        return super.getAvailableDestinations().filter((space) => space.y === 2);
+    getAvailableDestinations(cardIndex) {
+        return super.getAvailableDestinations(cardIndex).filter((space) => space.y === 2);
     }
 }

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

@@ -4,4 +4,5 @@ import { RuleId } from '../RuleId';
 export declare class CaimanEffectRule extends SacrificeEffectRule {
     ruleId: RuleId;
     onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number> | MoveItem<number, number, number>)[];
+    onRuleEnd(): never[];
 }

package/dist/rules/effects/CaimanEffectRule.js

@@ -4,20 +4,29 @@ 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 CaimanEffectRule extends SacrificeEffectRule {
     ruleId = RuleId.CaimanEffect;
     onSacrifice(move) {
+        if (this.remind(Memory.EffectCount)) {
+            return [];
+        }
         const card = this.material(MaterialType.EntityCard).getItem(move.itemIndex);
         const mythology = entityMythology(card.id.front);
         const pantheon = new Pantheon(this.game, this.player);
         const others = pantheon.visibleEntities
             .location((l) => l.x !== card.location.x || l.y !== card.location.y)
             .id((id) => entityMythology(id.front) === mythology);
+        this.memorize(Memory.EffectCount, 1 + others.length);
         return [
             ...others.moveItems({ type: LocationType.PlayerDiscard, player: this.player }),
             pantheon.gainGems(1 + others.length),
             this.customMove(CustomMoveType.EndEffect)
         ];
     }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
 }

package/dist/rules/effects/QilinEffectRule.js

@@ -1,7 +1,7 @@
 import { MoveKind } from '@gamepark/rules-api';
 import { CustomMoveType } from '../../CustomMoveType';
 import { Entity, isCreature } from '../../material/Entity';
-import { isPlaced, isTriggeredEffect } from '../../material/entity/Effect';
+import { isTriggeredEffect } from '../../material/entity/Effect';
 import { getEffects } from '../../material/entity/EntityDescription';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { MaterialType } from '../../material/MaterialType';
@@ -10,14 +10,15 @@ import { RuleId } from '../RuleId';
 export class QilinEffectRule extends PlayerEffectRule {
     ruleId = RuleId.QilinEffect;
     getPlayerMoves() {
+        const { triggerEvent } = this.getEffect();
         const cardsToCopy = [];
         for (const player of this.game.players) {
             if (player !== this.player) {
                 cardsToCopy.push(...new Pantheon(this.game, player).visibleEntities
                     .location((l) => l.x === this.card.location.x)
-                    .id((id) => isCreature(id.front) &&
-                    id.front !== Entity.Qilin &&
-                    getEffects(id.front).some((effect) => isTriggeredEffect(effect) && effect.trigger === isPlaced))
+                    .filter((card, cardIndex) => isCreature(card.id.front) &&
+                    card.id.front !== Entity.Qilin &&
+                    getEffects(card.id.front).some((effect) => isTriggeredEffect(effect) && effect.trigger(triggerEvent, { cardIndex, cardLocation: card.location, game: this.game })))
                     .getIndexes());
             }
         }
@@ -25,10 +26,13 @@ export class QilinEffectRule extends PlayerEffectRule {
     }
     onCustomMove(move) {
         if (move.type === CustomMoveType.ChooseEntityCard) {
-            const card = this.material(MaterialType.EntityCard).getItem(move.data);
+            const { triggerEvent } = this.getEffect();
+            const cardIndex = move.data;
+            const card = this.material(MaterialType.EntityCard).getItem(cardIndex);
+            const context = { cardIndex, cardLocation: card.location, game: this.game };
             const effect = getEffects(card.id.front)
                 .filter(isTriggeredEffect)
-                .find((effect) => effect.trigger === isPlaced);
+                .find((effect) => effect.trigger(triggerEvent, context));
             const moves = new effect.rule(this.game).playEffect();
             if (!moves.some((move) => move.kind === MoveKind.RulesMove)) {
                 moves.push(this.customMove(CustomMoveType.EndEffect));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -27,5 +27,6 @@
   "devDependencies": {
     "@gamepark/rules-api": "~7.2.0",
     "es-toolkit": "^1.44.0"
-  }
+  },
+  "gitHead": "6333853529378cbbf1535c58e13a015919adf186"
 }