@gamepark/mythologies 1.0.18 → 1.0.20

package/dist/Memory.d.ts

@@ -10,5 +10,6 @@ export declare enum Memory {
     EntityMoved = 9,
     TargetMythology = 10,
     TargetPlane = 11,
-    TargetLocations = 12
+    TargetLocations = 12,
+    ExiledEntities = 13
 }

package/dist/Memory.js

@@ -12,4 +12,5 @@ export var Memory;
     Memory[Memory["TargetMythology"] = 10] = "TargetMythology";
     Memory[Memory["TargetPlane"] = 11] = "TargetPlane";
     Memory[Memory["TargetLocations"] = 12] = "TargetLocations";
+    Memory[Memory["ExiledEntities"] = 13] = "ExiledEntities";
 })(Memory || (Memory = {}));

package/dist/MythologiesRules.d.ts

@@ -153,7 +153,7 @@ export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, M
     };
     keepMoveSecret(move: MaterialMove): boolean;
     isPlayerDestiny(move: MoveItem): boolean;
-    beforeItemMove(move: ItemMove): MaterialMove<PlayerColor, MaterialType, LocationType, number>[];
+    beforeItemMove(move: ItemMove): MaterialMove<PlayerColor, MaterialType, LocationType, number, number>[];
     getAutomaticMoves(): import("@gamepark/rules-api").StartRule<RuleId.ResolveEffects>[] | import("@gamepark/rules-api").StartPlayerTurn<PlayerColor, RuleId.ResolveEffects>[];
     giveTime(): number;
     getScore(player: PlayerColor): number;

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, isDeleteItemType, isMoveItemType, PositiveSequenceStrategy, SecretMaterialRules, StackingStrategy } from '@gamepark/rules-api';
 import { Destiny } from './material/Destiny';
 import { isGod } from './material/Entity';
 import { LineEventType, TriggerEventType } from './material/entity/Effect';
@@ -171,6 +171,15 @@ export class MythologiesRules extends SecretMaterialRules {
         if (!this.game.rule)
             return [];
         const consequences = super.beforeItemMove(move);
+        if (isDeleteItemType(MaterialType.EntityCard)(move)) {
+            const exiled = this.remind(Memory.ExiledEntities);
+            if (exiled !== undefined) {
+                const entity = this.material(MaterialType.EntityCard).getItem(move.itemIndex).id.front;
+                if (entity) {
+                    this.memorize(Memory.ExiledEntities, [...exiled, entity]);
+                }
+            }
+        }
         if (isMoveItemType(MaterialType.GemToken)(move) && move.location.type === LocationType.PlayerGems) {
             const gem = this.material(MaterialType.GemToken).getItem(move.itemIndex).location;
             const player = gem.player;

package/dist/MythologiesSetup.js

@@ -11,6 +11,7 @@ export class MythologiesSetup extends MaterialGameSetup {
     Rules = MythologiesRules;
     setupMaterial(options) {
         this.memorize(Memory.PendingEffects, []);
+        this.memorize(Memory.ExiledEntities, []);
         this.setupMythologies(this.getMythologies(options));
         this.setupPlayers();
         this.dealCreatures();

package/dist/material/Pantheon.js

@@ -106,7 +106,7 @@ export class Pantheon extends MaterialRulesPart {
         if (summoned) {
             moves.push(...this.onSummon(move));
         }
-        this.updateGrid(grid, { type: TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity, location, summoned: summoned });
+        this.updateGrid(grid, { type: TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity, location, summoned });
         return moves;
     }
     get isSummon() {

package/dist/material/entity/PlaceCardEffectRule.js

@@ -1,6 +1,7 @@
 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';
@@ -30,7 +31,8 @@ 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 pantheon = new Pantheon(this.game, player);
+        const cards = this.getCardsToPlace(cardIndex).id((id) => !isGod(id.front) || pantheon.gems >= 4);
         return this.getAvailableDestinations(cardIndex).flatMap(({ x, y }) => {
             return cards.moveItems({ type: LocationType.Pantheon, player, x, y });
         });

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

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

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

@@ -1,11 +1,12 @@
 import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { ColumnEvent, LineEvent } from '../../material/entity/Effect';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class CyclopsEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     getPlayerMoves(): MaterialMove[];
-    afterItemMove(move: ItemMove): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").MoveItem<number, number, number>)[];
+    afterItemMove(move: ItemMove): (import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>)[];
     takeNeighborsBonus(event?: LineEvent | ColumnEvent): import("@gamepark/rules-api").MoveItem<number, number, number>[];
     getBonus(event?: LineEvent | ColumnEvent): import("@gamepark/rules-api").Material<number, number, number>;
 }

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

@@ -1,4 +1,5 @@
 import { Location, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { RuleId } from '../RuleId';
 export declare class DullahanEffectRule extends MoveEffectRule {
@@ -8,6 +9,6 @@ export declare class DullahanEffectRule extends MoveEffectRule {
     isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
     getPlayerMoves(): MaterialMove[];
     onCardMoved(move: MoveItem): MaterialMove[];
-    onCardSacrificed(move: MoveItem): import("@gamepark/rules-api").CustomMove[];
+    onCardSacrificed(move: MoveItem): import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>[];
     onRuleEnd(): never[];
 }

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

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

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

@@ -1,8 +1,9 @@
 import { MoveItem } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
 export declare class GorgonEffectRule extends SacrificeEffectRule {
     ruleId: RuleId;
     getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CreateItem<number, number, number> | import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>)[];
 }

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

@@ -1,11 +1,12 @@
 import { CustomMove, Material } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { SimultaneousSacrificeEffectRule } from '../../material/entity/SimultaneousSacrificeEffectRule';
 import { PlayerColor } from '../../PlayerColor';
 import { RuleId } from '../RuleId';
 export declare class IllapaEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
-    getPlayerMoves(): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChoosePlan, number>[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
 }
 export declare class IllapaSacrificeRule extends SimultaneousSacrificeEffectRule {

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

@@ -1,8 +1,9 @@
 import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class JiangshiEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     getPlayerMoves(): MaterialMove[];
-    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CreateItem<number, number, number> | import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>)[];
 }

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

@@ -1,9 +1,10 @@
 import { ItemMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class LeprechaunEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     canPlayEffect(cardIndex: number): boolean;
     getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MoveItem<number, number, number>[];
-    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>[];
 }

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

@@ -1,11 +1,13 @@
 import { CustomMove, MaterialItem, PlayerTurnRule } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { EntityId } from '../../material/Entity';
 import { LocationType } from '../../material/LocationType';
 import { MaterialType } from '../../material/MaterialType';
+import { Mythology } from '../../material/Mythology';
 import { PlayerColor } from '../../PlayerColor';
 import { RuleId } from '../RuleId';
 export declare class OdinEffectRule extends PlayerTurnRule {
-    getPlayerMoves(): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChooseMythology, Mythology>[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").StartRule<RuleId.DrawDestinyCard>[];
     isCardRestricted(card: MaterialItem<MaterialType, LocationType, EntityId>, player?: PlayerColor): boolean;
 }

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

@@ -1,8 +1,9 @@
 import { CustomMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class QilinEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
-    getPlayerMoves(): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChooseEntityCard, number>[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
 }

package/dist/rules/effects/RakshasaEffectRule.js

@@ -17,7 +17,6 @@ export class RakshasaEffectRule extends PlaceCardEffectRule {
     }
     getAvailableDestinations(cardIndex) {
         const location = this.material(MaterialType.EntityCard).getItem(cardIndex).location;
-        const pantheon = new Pantheon(this.game, location.player);
-        return pantheon.isLegalSpaceToSummon(location) ? [location] : [];
+        return [location];
     }
 }

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

@@ -1,4 +1,5 @@
 import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule, RuleMove, RuleStep } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { CardEffect, PlayerPendingEffects } from '../../material/entity/Effect';
 import { RuleId } from '../RuleId';
 export declare class ResolveEffectsRule extends PlayerTurnRule {
@@ -6,8 +7,8 @@ export declare class ResolveEffectsRule extends PlayerTurnRule {
     isAutoEffects(pendingEffects: PlayerPendingEffects): boolean;
     onRuleStart(_move: RuleMove, previousRule: RuleStep): MaterialMove[];
     getPendingEffects(): PlayerPendingEffects | undefined;
-    getPlayerMoves(): CustomMove[] | import("@gamepark/rules-api").MoveItem<number, number, number>[];
-    beforeItemMove(move: ItemMove): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.PlayEffect, CardEffect<import("../../material/entity/Effect").TriggerEvent>>[] | import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    beforeItemMove(move: ItemMove): CustomMove<CustomMoveType.EndEffect, any>[];
     onCustomMove(move: CustomMove): MaterialMove[];
     onPlayEffect(effect: CardEffect): MaterialMove[];
     playEffect(cardEffect: CardEffect): MaterialMove[];

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

@@ -1,8 +1,9 @@
 import { ItemMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class SelkieEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     getPlayerMoves(): import("@gamepark/rules-api").CreateItem<number, number, number>[];
-    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>[];
 }

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

@@ -1,4 +1,5 @@
 import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class ShivaEffectRule extends PlayerEffectRule {
@@ -6,5 +7,5 @@ export declare class ShivaEffectRule extends PlayerEffectRule {
     canPlayEffect(cardIndex: number): boolean;
     onRuleStart(): MaterialMove[];
     getPlayerMoves(cardIndex?: number): import("@gamepark/rules-api").MoveItemsAtOnce<number, number, number>[];
-    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+    beforeItemMove(move: ItemMove): (import("@gamepark/rules-api").CreateItem<number, number, number> | import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>)[];
 }

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

@@ -10,7 +10,7 @@ export declare class SupayEffectRule extends PlayerEffectRule {
     getRules(): (SupayMoveRule | SupaySacrificeRule)[];
     getPlayerMoves(): MaterialMove[];
     beforeItemMove(move: ItemMove): MaterialMove[];
-    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number, number>[];
     onEndEffect(): MaterialMove[];
 }
 export declare class SupaySacrificeRule extends SacrificeEffectRule {

package/dist/rules/effects/TriggerEffectsRule.js

@@ -26,16 +26,16 @@ export class TriggerEffectsRule extends MaterialRulesPart {
             if (event.type === TriggerEventType.EntityCrushed) {
                 const location = material.getItem(event.cardIndex).location;
                 if (location.player === player && !cards.some((card) => card.index === event.cardIndex)) {
-                    cards.push({ index: event.cardIndex, location });
+                    cards.push({ index: event.cardIndex, location, entity: event.card.id.front });
                 }
             }
             if (event.type === TriggerEventType.EntityPlaced && event.location.player === player && !cards.some((card) => card.index === event.cardIndex)) {
-                cards.push({ index: event.cardIndex, location: event.location });
+                cards.push({ index: event.cardIndex, location: event.location, entity: event.entity });
             }
         }
         for (const triggerEvent of triggerEvents) {
-            for (const { index, location } of cards) {
-                pendingEffects.push(...this.getCardEffects(index, location, triggerEvent));
+            for (const { index, location, entity } of cards) {
+                pendingEffects.push(...this.getCardEffects(index, location, triggerEvent, entity));
             }
         }
         return pendingEffects;

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

@@ -1,4 +1,5 @@
 import { MaterialItem, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { RuleId } from '../RuleId';
 export declare class VetalaEffectRule extends MoveEffectRule {
@@ -6,7 +7,7 @@ export declare class VetalaEffectRule extends MoveEffectRule {
     onRuleStart(): MaterialMove[];
     getPlayerMoves(): MaterialMove[];
     getAvailableDestinations(card: MaterialItem, cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
-    onCardMoved(): import("@gamepark/rules-api").CustomMove[];
-    onCardSacrificed(move: MoveItem): import("@gamepark/rules-api").CustomMove[];
+    onCardMoved(): import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>[];
+    onCardSacrificed(move: MoveItem): import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>[];
     onRuleEnd(): never[];
 }

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

@@ -1,8 +1,9 @@
 import { MoveItem } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
 import { RuleId } from '../RuleId';
 export declare class ViracochaEffectRule extends SacrificeEffectRule {
     ruleId: RuleId;
     getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
-    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+    onSacrifice(move: MoveItem): (import("@gamepark/rules-api").CreateItem<number, number, number> | import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>)[];
 }

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

@@ -1,10 +1,11 @@
 import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class VishnuEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
     playEffect(): (import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").StartRule<RuleId>)[];
     onRuleStart(): MaterialMove[];
-    getPlayerMoves(): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChooseEntityCard, number>[];
     onCustomMove(move: CustomMove): MaterialMove[];
 }

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

@@ -1,9 +1,10 @@
 import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
 import { PlayerEffectRule } from '../../material/entity/PlayerEffectRule';
 import { RuleId } from '../RuleId';
 export declare class YanluoWangEffectRule extends PlayerEffectRule {
     ruleId: RuleId;
-    onRuleStart(): import("@gamepark/rules-api").CustomMove[];
+    onRuleStart(): import("@gamepark/rules-api").CustomMove<CustomMoveType.EndEffect, any>[];
     getPlayerMoves(): MaterialMove[];
     afterItemMove(move: ItemMove): import("@gamepark/rules-api").MoveItem<number, number, number>[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -25,8 +25,8 @@
     "es-toolkit": "^1.44.0"
   },
   "devDependencies": {
-    "@gamepark/rules-api": "~7.5.0",
+    "@gamepark/rules-api": "~7.6.0",
     "es-toolkit": "^1.44.0"
   },
-  "gitHead": "4c0737af50e4ffea5cd9a6facc9afbeebb2b0e77"
+  "gitHead": "b649962b19027188e947f0996da7c1b3fd73efc4"
 }