@gamepark/mythologies 1.0.1 → 1.0.3

package/dist/MythologiesRules.js

@@ -1,4 +1,4 @@
-import { FillGapStrategy, hideFront, hideFrontToOthers, hideItemId, isMoveItemType, PositiveSequenceStrategy, SecretMaterialRules, StackingStrategy } from '@gamepark/rules-api';
+import { FillGapStrategy, hideFront, hideFrontToOthers, hideItemId, isMoveItemType, isMoveItemTypeAtOnce, PositiveSequenceStrategy, SecretMaterialRules, StackingStrategy } from '@gamepark/rules-api';
 import { Destiny } from './material/Destiny';
 import { isGod } from './material/Entity';
 import { LineEventType, TriggerEventType } from './material/entity/Effect';
@@ -189,6 +189,12 @@ export class MythologiesRules extends SecretMaterialRules {
                 new Pantheon(this.game, card.location.player).onEntitySacrificed(move.itemIndex);
             }
         }
+        if (isMoveItemTypeAtOnce(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
+            const firstCard = this.material(MaterialType.EntityCard).getItem(move.indexes[0]);
+            if (firstCard.location.type === LocationType.Pantheon) {
+                new Pantheon(this.game, firstCard.location.player).onPileSacrificed(move.indexes);
+            }
+        }
         return super.beforeItemMove(move);
     }
     getAutomaticMoves() {

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[];
@@ -44,6 +44,7 @@ export declare class Pantheon extends MaterialRulesPart {
     get mythologies(): import("./Mythology").Mythology[];
     get missingMythologies(): import("./Mythology").Mythology[];
     onEntitySacrificed(cardIndex: number): void;
+    onPileSacrificed(indexes: number[]): void;
     isOpponentOngoingEffect(): boolean;
     replaceSacrifice(cards: EntityItem[]): Material<number, number, number>;
     sacrificeToPreventMove(): MoveItem<number, number, number>[];

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));
                 }
             }
         }
@@ -283,6 +284,17 @@ export class Pantheon extends MaterialRulesPart {
             new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.EntitySacrificed, card: card, cardIndex });
         }
     }
+    onPileSacrificed(indexes) {
+        const cards = indexes.map((index) => this.material(MaterialType.EntityCard).getItem(index));
+        const { x, y } = cards[0].location;
+        const grid = this.indexGrid;
+        grid[y][x] = null;
+        this.memorize(Memory.PlayerGrid, grid, this.player);
+        const triggerEffects = new TriggerEffectsRule(this.game);
+        for (const cardIndex of indexes) {
+            triggerEffects.triggerEffects({ type: TriggerEventType.EntitySacrificed, card: cards[indexes.indexOf(cardIndex)], cardIndex });
+        }
+    }
     isOpponentOngoingEffect() {
         const ongoingEffect = this.remind(Memory.OngoingEffect);
         if (!ongoingEffect)

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

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

package/dist/material/entity/PlaceCardEffectRule.js

@@ -52,7 +52,8 @@ export class PlaceCardEffectRule extends PlayerEffectRule {
 }
 export class SummonEffectRule extends PlaceCardEffectRule {
     isSummon = true;
-    getAvailableDestinations() {
-        return new Pantheon(this.game, this.player).legalSpacesToSummon;
+    getAvailableDestinations(cardIndex) {
+        const entity = this.material(MaterialType.EntityCard).getItem(cardIndex).id.front;
+        return new Pantheon(this.game, this.player).getLegalSpacesToSummon(entity);
     }
 }

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

@@ -5,9 +5,10 @@ export const Brahma = {
     summon: [{ gem: 1, favor: 1 }, {}, { gem: 1 }],
     effect: {
         trigger: (event) => event.type === TriggerEventType.EntitySacrificed,
+        auto: true,
         rule: class BrahmaEffectRule extends PlayerEffectRule {
             playEffect() {
-                return [new Pantheon(this.game, this.player).gainGems(2)];
+                return [new Pantheon(this.game, this.card.location.player).gainGems(2)];
             }
         }
     }

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/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.1",
+  "version": "1.0.3",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -28,5 +28,5 @@
     "@gamepark/rules-api": "~7.2.0",
     "es-toolkit": "^1.44.0"
   },
-  "gitHead": "624406ecd16bb8dbc98345789e5d767fdf49f1f8"
+  "gitHead": "5979bb8560edd48228052e30e8097060c49e6ff8"
 }