@gamepark/mythologies 1.0.6 → 1.0.8

package/dist/material/Pantheon.d.ts

@@ -25,10 +25,10 @@ export declare class Pantheon extends MaterialRulesPart {
     loseFavor(quantity?: number): import("@gamepark/rules-api").DeleteItem<number>;
     onCardPlaced(move: MoveItem): MaterialMove[];
     get isSummon(): boolean;
-    updateGrid(gridAfter?: (number | null)[][]): TriggerEvent[];
+    updateGrid(gridAfter?: (number | null)[][], ...additionalEvents: TriggerEvent[]): void;
     private getEntitiesMoved;
     private getEntitiesCrushed;
-    triggerBonusGains(grid?: (number | null)[][], gridBefore?: (number | null)[][] | null): void;
+    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

@@ -97,25 +97,18 @@ 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;
-        const triggerEffectsRule = new TriggerEffectsRule(this.game);
-        triggerEffectsRule.triggerCardEffect(move.itemIndex, location, { type: TriggerEventType.SelfPlaced, crush }, entity);
+        new TriggerEffectsRule(this.game).triggerCardEffect(move.itemIndex, location, { type: TriggerEventType.SelfPlaced, crush }, entity);
         const summoned = this.isSummon;
         if (summoned) {
             moves.push(...this.onSummon(move));
         }
-        const gridBefore = this.remind(Memory.PlayerGrid, this.player);
-        const triggerEvents = this.updateGrid(grid);
-        triggerEvents.push({ type: TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity, location, summoned: summoned });
-        if (triggerEvents.length) {
-            triggerEffectsRule.triggerEffects(...triggerEvents);
-        }
-        this.triggerBonusGains(grid, gridBefore);
+        this.updateGrid(grid, { type: TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity, location, summoned: summoned });
         return moves;
     }
     get isSummon() {
         return new MythologiesRules(this.game).delegate().isSummon;
     }
-    updateGrid(gridAfter = this.indexGrid) {
+    updateGrid(gridAfter = this.indexGrid, ...additionalEvents) {
         const gridBefore = this.remind(Memory.PlayerGrid, this.player) ?? this.indexGrid;
         this.memorize(Memory.PlayerGrid, gridAfter, this.player);
         const triggerEvents = [];
@@ -137,7 +130,11 @@ export class Pantheon extends MaterialRulesPart {
                 triggerEvents.push({ type: TriggerEventType.ColumnEvent, eventType: LineEventType.Completed, player: this.player, x });
             }
         }
-        return triggerEvents;
+        triggerEvents.push(...additionalEvents);
+        if (triggerEvents.length) {
+            new TriggerEffectsRule(this.game).triggerEffects(...triggerEvents);
+        }
+        this.triggerBonusGains(gridAfter);
     }
     getEntitiesMoved(before, after) {
         const entities = [];
@@ -164,11 +161,13 @@ export class Pantheon extends MaterialRulesPart {
         }
         return entities;
     }
-    triggerBonusGains(grid = this.indexGrid, gridBefore) {
+    triggerBonusGains(grid = this.indexGrid) {
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        const pendingBonusGains = pendingEffects.filter((e) => e.type === PendingEffectsType.BonusGains && e.player === this.player);
         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) {
-            if (gridBefore && gridBefore[y].every((item) => item !== null))
+            if (pendingBonusGains.some((e) => e.lines.includes(y)))
                 continue;
             if (this.getBonusGem(y).length) {
                 effect.lines.push(y);
@@ -176,14 +175,14 @@ export class Pantheon extends MaterialRulesPart {
         }
         const fullColumns = range(0, 3).filter((x) => grid.every((line) => line[x] !== null));
         for (const x of fullColumns) {
-            if (gridBefore && gridBefore.every((line) => line[x] !== null))
+            if (pendingBonusGains.some((e) => e.columns.includes(x)))
                 continue;
             if (this.getBonusFavor(x).length) {
                 effect.columns.push(x);
             }
         }
         if (effect.lines.length || effect.columns.length) {
-            this.remind(Memory.PendingEffects).unshift(effect);
+            pendingEffects.unshift(effect);
         }
     }
     gainLineBonus(y) {

package/dist/material/entity/MoveEffectRule.js

@@ -1,7 +1,6 @@
 import { isMoveItemType } from '@gamepark/rules-api';
 import { isEqual } from 'es-toolkit';
 import { CustomMoveType } from '../../CustomMoveType';
-import { TriggerEffectsRule } from '../../rules/effects/TriggerEffectsRule';
 import { LocationType } from '../LocationType';
 import { MaterialType } from '../MaterialType';
 import { Pantheon } from '../Pantheon';
@@ -67,7 +66,6 @@ export class MoveEffectRule extends PlayerEffectRule {
         return super.onEndEffect();
     }
     updateGridAfterMoves() {
-        const pantheon = new Pantheon(this.game, this.player);
-        new TriggerEffectsRule(this.game).triggerEffects(...pantheon.updateGrid());
+        new Pantheon(this.game, this.player).updateGrid();
     }
 }

package/dist/material/entity/SimultaneousMoveEffectRule.js

@@ -53,12 +53,8 @@ export class SimultaneousMoveEffectRule extends SimultaneousEffectRule {
         return super.getMovesAfterPlayersDone();
     }
     updatePlayersGrids() {
-        const events = [];
-        const triggerEffectsRule = new TriggerEffectsRule(this.game);
-        for (const player of triggerEffectsRule.getPlayersByEffectPriorityOrder()) {
-            const pantheon = new Pantheon(this.game, player);
-            events.push(...pantheon.updateGrid());
+        for (const player of new TriggerEffectsRule(this.game).getPlayersByEffectPriorityOrder()) {
+            new Pantheon(this.game, player).updateGrid();
         }
-        triggerEffectsRule.triggerEffects(...events);
     }
 }

package/dist/material/entity/egyptian/Osiris.js

@@ -1,4 +1,4 @@
-import { range, uniq } from 'es-toolkit';
+import { uniq } from 'es-toolkit';
 import { entityMythology } from '../../Entity';
 import { Mythology } from '../../Mythology';
 import { Pantheon } from '../../Pantheon';
@@ -13,10 +13,8 @@ export const Osiris = {
                 const pantheon = new Pantheon(this.game, this.player);
                 const grid = pantheon.grid;
                 const mythologiesPerLine = grid.map((line) => line.filter((space) => space !== undefined).map(entityMythology));
-                const otherMythologies = Math.max(...range(0, 3).map((skipY) => {
-                    const mythologies = uniq(mythologiesPerLine.flatMap((mythologies, y) => (y !== skipY ? mythologies : [])));
-                    return mythologies.filter((mythology) => mythology !== Mythology.Egyptian).length;
-                }));
+                const allMythologies = uniq(mythologiesPerLine.flat()).filter((m) => m !== Mythology.Egyptian);
+                const otherMythologies = allMythologies.filter((m) => mythologiesPerLine.filter((line) => line.includes(m)).length >= 2).length;
                 return otherMythologies > 0 ? [pantheon.gainFavor(otherMythologies * 2)] : [];
             }
         }

package/dist/rules/effects/AthenaEffectRule.js

@@ -4,7 +4,6 @@ import { LocationType } from '../../material/LocationType';
 import { Pantheon } from '../../material/Pantheon';
 import { Memory } from '../../Memory';
 import { RuleId } from '../RuleId';
-import { TriggerEffectsRule } from './TriggerEffectsRule';
 export class AthenaEffectRule extends PlayerEffectRule {
     ruleId = RuleId.AthenaEffect;
     onRuleStart() {
@@ -37,8 +36,7 @@ export class AthenaEffectRule extends PlayerEffectRule {
         return moves;
     }
     onEndEffect() {
-        const pantheon = new Pantheon(this.game, this.player);
-        new TriggerEffectsRule(this.game).triggerEffects(...pantheon.updateGrid());
+        new Pantheon(this.game, this.player).updateGrid();
         return super.onEndEffect();
     }
     onRuleEnd() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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": "7ed053c2f24dabb62f2448977f9ce938defb76bf"
 }