@gamepark/mythologies 1.0.4 → 1.0.6

package/dist/MythologiesRules.d.ts

@@ -9,7 +9,7 @@ import { AmmoutEffectRule } from './rules/effects/AmmoutEffectRule';
 import { AnubisEffectRule } from './rules/effects/AnubisEffectRule';
 import { AthenaEffectRule } from './rules/effects/AthenaEffectRule';
 import { BennuEffectRule } from './rules/effects/BennuEffectRule';
-import { CaimanEffectRule } from './rules/effects/CaimanEffectRule';
+import { CaimanEffectRule, CaimanSacrificeEffectRule } from './rules/effects/CaimanEffectRule';
 import { CentaurEffectRule, CentaurEffectSacrificeRule } from './rules/effects/CentaurEffectRule';
 import { ChimeraEffectRule } from './rules/effects/ChimeraEffectRule';
 import { CobraEffectRule, CobraSummonEffect } from './rules/effects/CobraEffectRule';
@@ -98,6 +98,7 @@ export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, M
         41: typeof IllapaEffectRule;
         42: typeof IllapaSacrificeRule;
         43: typeof CaimanEffectRule;
+        64: typeof CaimanSacrificeEffectRule;
         44: typeof CondorEffectRule;
         45: typeof SupayEffectRule;
         46: typeof UkukuEffectRule;
@@ -143,7 +144,7 @@ export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, M
             6: (item: MaterialItem, player?: PlayerColor) => string[];
         };
         4: {
-            5: import("@gamepark/rules-api").HidingStrategy<number, number>;
+            5: import("@gamepark/rules-api").HidingStrategy;
             17: (item: MaterialItem) => string[];
         };
         10: {

package/dist/MythologiesRules.js

@@ -13,7 +13,7 @@ import { AmmoutEffectRule } from './rules/effects/AmmoutEffectRule';
 import { AnubisEffectRule } from './rules/effects/AnubisEffectRule';
 import { AthenaEffectRule } from './rules/effects/AthenaEffectRule';
 import { BennuEffectRule } from './rules/effects/BennuEffectRule';
-import { CaimanEffectRule } from './rules/effects/CaimanEffectRule';
+import { CaimanEffectRule, CaimanSacrificeEffectRule } from './rules/effects/CaimanEffectRule';
 import { CentaurEffectRule, CentaurEffectSacrificeRule } from './rules/effects/CentaurEffectRule';
 import { ChimeraEffectRule } from './rules/effects/ChimeraEffectRule';
 import { CobraEffectRule, CobraSummonEffect } from './rules/effects/CobraEffectRule';
@@ -103,6 +103,7 @@ export class MythologiesRules extends SecretMaterialRules {
         [RuleId.IllapaEffect]: IllapaEffectRule,
         [RuleId.IllapaSacrifice]: IllapaSacrificeRule,
         [RuleId.CaimanEffect]: CaimanEffectRule,
+        [RuleId.CaimanSacrificeEffect]: CaimanSacrificeEffectRule,
         [RuleId.CondorEffect]: CondorEffectRule,
         [RuleId.SupayEffect]: SupayEffectRule,
         [RuleId.UkukuEffect]: UkukuEffectRule,
@@ -169,18 +170,27 @@ export class MythologiesRules extends SecretMaterialRules {
     beforeItemMove(move) {
         if (!this.game.rule)
             return [];
+        const consequences = super.beforeItemMove(move);
         if (isMoveItemType(MaterialType.GemToken)(move) && move.location.type === LocationType.PlayerGems) {
             const gem = this.material(MaterialType.GemToken).getItem(move.itemIndex).location;
             const player = gem.player;
             if (gem.type === LocationType.PantheonLineBonus && player === move.location.player) {
+                const firstEffect = this.remind(Memory.PendingEffects)[0];
                 new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.LineEvent, eventType: LineEventType.BonusGain, player, y: gem.y });
+                if (this.remind(Memory.PendingEffects)[0] !== firstEffect) {
+                    consequences.push(...new ResolveEffectsRule(this.game).startEffectsResolution());
+                }
             }
         }
         if (isMoveItemType(MaterialType.FavorToken)(move) && move.location.type === LocationType.PlayerFavor) {
             const favor = this.material(MaterialType.FavorToken).getItem(move.itemIndex).location;
             const player = favor.player;
             if (favor.type === LocationType.PantheonColumnBonus && player === move.location.player) {
+                const firstEffect = this.remind(Memory.PendingEffects)[0];
                 new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.ColumnEvent, eventType: LineEventType.BonusGain, player, x: favor.x });
+                if (this.remind(Memory.PendingEffects)[0] !== firstEffect) {
+                    consequences.push(...new ResolveEffectsRule(this.game).startEffectsResolution());
+                }
             }
         }
         if (isMoveItemType(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
@@ -195,7 +205,7 @@ export class MythologiesRules extends SecretMaterialRules {
                 new Pantheon(this.game, firstCard.location.player).onPileSacrificed(move.indexes);
             }
         }
-        return super.beforeItemMove(move);
+        return consequences;
     }
     getAutomaticMoves() {
         if (!this.remind(Memory.OngoingEffect) &&

package/dist/material/Pantheon.d.ts

@@ -10,7 +10,6 @@ export declare class Pantheon extends MaterialRulesPart {
     get coveredEntities(): Material<number, number, number>;
     get grid(): (Entity | undefined)[][];
     private get indexGrid();
-    getLegalSpacesToSummon(entity: Entity): XYCoordinates[];
     isLegalSpaceToSummon(space: XYCoordinates, entity?: Entity): boolean;
     getFavorTax(space: XYCoordinates): number;
     getGemTax(space: XYCoordinates): number;
@@ -29,7 +28,7 @@ export declare class Pantheon extends MaterialRulesPart {
     updateGrid(gridAfter?: (number | null)[][]): TriggerEvent[];
     private getEntitiesMoved;
     private getEntitiesCrushed;
-    triggerBonusGains(grid?: (number | null)[][]): void;
+    triggerBonusGains(grid?: (number | null)[][], gridBefore?: (number | null)[][] | 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

@@ -38,9 +38,6 @@ export class Pantheon extends MaterialRulesPart {
             return entity.length > 0 ? entity.getIndex() : null;
         }));
     }
-    getLegalSpacesToSummon(entity) {
-        return this.legalSpaces.filter((space) => this.isLegalSpaceToSummon(space, entity));
-    }
     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));
@@ -106,18 +103,19 @@ export class Pantheon extends MaterialRulesPart {
         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);
         return moves;
     }
     get isSummon() {
         return new MythologiesRules(this.game).delegate().isSummon;
     }
     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 = [];
@@ -166,16 +164,20 @@ export class Pantheon extends MaterialRulesPart {
         }
         return entities;
     }
-    triggerBonusGains(grid = this.indexGrid) {
+    triggerBonusGains(grid = this.indexGrid, gridBefore) {
         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))
+                continue;
             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) {
+            if (gridBefore && gridBefore.every((line) => line[x] !== null))
+                continue;
             if (this.getBonusFavor(x).length) {
                 effect.columns.push(x);
             }

package/dist/material/entity/greek/Cyclops.js

@@ -1,14 +1,16 @@
 import { CyclopsEffectRule } from '../../../rules/effects/CyclopsEffectRule';
+import { PlaceCardsRule } from '../../../rules/PlaceCardsRule';
 import { LineEventType, TriggerEventType } from '../Effect';
 export const Cyclops = {
     summon: [{ favor: 1 }, { gem: 1 }, {}],
     effect: {
-        trigger: (event, { cardLocation, game }) => {
+        trigger: (event, { cardLocation, game, cardIndex }) => {
             const { x, y, player } = cardLocation;
             return (((event.type === TriggerEventType.ColumnEvent && event.x === x) || (event.type === TriggerEventType.LineEvent && event.y === y)) &&
                 event.eventType === LineEventType.BonusGain &&
                 event.player === player &&
-                new CyclopsEffectRule(game).getBonus(event).length > 0);
+                new CyclopsEffectRule(game).getBonus(event).length > 0 &&
+                new PlaceCardsRule(game).isOncePerTurnAvailable(cardIndex));
         },
         rule: CyclopsEffectRule
     }

package/dist/rules/RuleId.d.ts

@@ -58,5 +58,6 @@ export declare enum RuleId {
     LeprechaunEffect = 60,
     SelkieEffect = 61,
     DullahanEffect = 62,
-    GarudaSacrifice = 63
+    GarudaSacrifice = 63,
+    CaimanSacrificeEffect = 64
 }

package/dist/rules/RuleId.js

@@ -60,4 +60,5 @@ export var RuleId;
     RuleId[RuleId["SelkieEffect"] = 61] = "SelkieEffect";
     RuleId[RuleId["DullahanEffect"] = 62] = "DullahanEffect";
     RuleId[RuleId["GarudaSacrifice"] = 63] = "GarudaSacrifice";
+    RuleId[RuleId["CaimanSacrificeEffect"] = 64] = "CaimanSacrificeEffect";
 })(RuleId || (RuleId = {}));

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

@@ -1,8 +1,16 @@
-import { MoveItem } from '@gamepark/rules-api';
+import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
-export declare class CaimanEffectRule extends SacrificeEffectRule {
+export declare class CaimanEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
-    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number> | MoveItem<number, number, number>)[];
+    getPlayerMoves(): CustomMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+}
+export declare class CaimanSacrificeEffectRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): CustomMove[] | import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(): MaterialMove[];
     onRuleEnd(): never[];
 }

package/dist/rules/effects/CaimanEffectRule.js

@@ -1,32 +1,58 @@
 import { CustomMoveType } from '../../CustomMoveType';
 import { entityMythology } from '../../material/Entity';
+import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 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 {
+export class CaimanEffectRule extends PlayerEffectRule {
     ruleId = RuleId.CaimanEffect;
-    onSacrifice(move) {
-        if (this.remind(Memory.EffectCount)) {
-            return [];
+    getPlayerMoves() {
+        return this.material(MaterialType.MythologyBoard)
+            .getItems()
+            .map((item) => this.customMove(CustomMoveType.ChooseMythology, item.id.mythology));
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseMythology) {
+            this.memorize(Memory.TargetMythology, move.data);
+            return [this.startRule(RuleId.CaimanSacrificeEffect)];
+        }
+        return super.onCustomMove(move);
+    }
+}
+export class CaimanSacrificeEffectRule extends SacrificeEffectRule {
+    ruleId = RuleId.CaimanSacrificeEffect;
+    onRuleStart() {
+        const mythology = this.remind(Memory.TargetMythology);
+        const indexes = new Pantheon(this.game, this.player).visibleEntities.id((id) => entityMythology(id.front) === mythology).getIndexes();
+        if (!indexes.length)
+            return [this.customMove(CustomMoveType.EndEffect)];
+        this.memorize(Memory.TargetEntities, indexes);
+        this.memorize(Memory.EffectCount, indexes.length);
+        const moves = this.getPlayerMoves();
+        if (moves.length === indexes.length) {
+            return moves;
+        }
+        return [];
+    }
+    getCardsToSacrifice() {
+        const indexes = this.remind(Memory.TargetEntities);
+        return this.material(MaterialType.EntityCard).index(indexes);
+    }
+    onSacrifice() {
+        const moves = [];
+        moves.push(new Pantheon(this.game, this.player).gainGems(1));
+        const remaining = this.memorize(Memory.EffectCount, (count) => count - 1);
+        if (!remaining) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
         }
-        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)
-        ];
+        return moves;
     }
     onRuleEnd() {
+        this.forget(Memory.TargetEntities);
         this.forget(Memory.EffectCount);
+        this.forget(Memory.TargetMythology);
         return [];
     }
 }

package/dist/rules/effects/ResolveEffectsRule.js

@@ -39,6 +39,7 @@ export class ResolveEffectsRule extends PlayerTurnRule {
             throw new Error('Unexpected state: start ResolveEffectsRule without pending effects');
         }
         if (pendingEffects.type === PendingEffectsType.SummonGain) {
+            this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
             return [...new Pantheon(this.game, this.player).getSummonGains(pendingEffects.entity, pendingEffects.line), this.customMove(CustomMoveType.EndEffect)];
         }
         const moves = this.getPlayerMoves();
@@ -46,6 +47,7 @@ export class ResolveEffectsRule extends PlayerTurnRule {
             return moves;
         }
         else if (moves.length === 0) {
+            this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
             return [this.customMove(CustomMoveType.EndEffect)];
         }
         return [];
@@ -93,6 +95,7 @@ export class ResolveEffectsRule extends PlayerTurnRule {
                 pendingEffects.lines = pendingEffects.lines.filter((line) => line !== item.location.y);
             }
             if (this.getPlayerMoves().length === 0) {
+                this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
                 return [this.customMove(CustomMoveType.EndEffect)];
             }
         }
@@ -136,9 +139,6 @@ export class ResolveEffectsRule extends PlayerTurnRule {
         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/package.json

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