@gamepark/skyrift 0.3.0 → 0.4.1

package/dist/material/CardRule.js

@@ -1,9 +1,9 @@
 import { MaterialRulesPart } from '@gamepark/rules-api';
-import { CustomMoveType } from '../CustomMoveType';
 import { Memory } from '../Memory';
-import { RuleId } from '../rules/RuleId';
 import { cardProperties } from './CardProperties';
 import { CardSuit } from './CardSuit';
+import { CardType } from './CardType';
+import { createCardRule } from './createCardRule';
 import { LocationType } from './LocationType';
 import { MaterialType } from './MaterialType';
 import { OngoingEffectType } from './OngoingEffect';
@@ -13,40 +13,16 @@ export class CardRule extends MaterialRulesPart {
         super(game);
         this.index = index;
     }
-    onEnters() {
-        if (this.entersEffect || this.challenge) {
-            this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index, challenge: this.challenge }]);
-        }
-        return [];
-    }
-    onPlayerTurnStart(_player) {
-        return [];
-    }
-    onRoundEnd(win) {
-        return win ? this.onWinRound() : this.onLoseRound();
-    }
-    onWinRound() {
-        return [];
-    }
-    onLoseRound() {
-        return [];
-    }
-    onCardEnters(_card, _side) {
-        return [];
-    }
-    oncePerTurnEffect = false;
-    entersEffect = false;
-    challenge = false;
-    onChallengeAccepted() {
-        return [this.customMove(CustomMoveType.EndEffect)];
+    canActivate() {
+        if (!this.activate)
+            return false;
+        if (this.isStunned())
+            return false;
+        const activatedCards = this.remind(Memory.ActivatedCards);
+        return !activatedCards.includes(this.index);
     }
-    onChallengeDeclined() {
-        this.memorize(Memory.PendingEffects, []);
-        this.memorize(Memory.ChallengeConceded, true);
-        return [this.startPlayerTurn(RuleId.EndRound, this.opponent)];
-    }
-    onLeave() {
-        return [...this.removePowerTokens(), ...this.removeStunTokens()];
+    onLeaves() {
+        return [...this.removePowerTokens(), ...this.removeStunTokens(), ...this.removeSpecialTokens()];
     }
     removePowerTokens() {
         const tokens = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index);
@@ -56,6 +32,10 @@ export class CardRule extends MaterialRulesPart {
         const tokens = this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index);
         return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
     }
+    removeSpecialTokens() {
+        const tokens = this.material(MaterialType.SpecialToken).location(LocationType.CardSpecialTokens).parent(this.index);
+        return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
+    }
     get item() {
         return this.material(MaterialType.Card).getItem(this.index);
     }
@@ -65,6 +45,12 @@ export class CardRule extends MaterialRulesPart {
     get properties() {
         return cardProperties[this.card];
     }
+    get playArea() {
+        return this.material(MaterialType.Card).location(LocationType.PlayArea);
+    }
+    get creatures() {
+        return this.playArea.id((id) => cardProperties[id.front].type === CardType.Creature);
+    }
     isStunned() {
         return this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index).getQuantity() > 0;
     }
@@ -73,7 +59,7 @@ export class CardRule extends MaterialRulesPart {
             return 0;
         }
         else {
-            return this.getPowerIfNotStunned();
+            return Math.max(this.getPowerIfNotStunned(), 0);
         }
     }
     getPowerIfNotStunned() {
@@ -81,48 +67,45 @@ export class CardRule extends MaterialRulesPart {
         const powerTokensCount = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index).getQuantity();
         return basePower + powerTokensCount;
     }
-    addPendingEffect() {
-        this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index }]);
+    addPendingEffect(ruleId) {
+        this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index, ruleId }]);
     }
     addOngoingEffect(type) {
         this.memorize(Memory.OngoingEffects, (effects) => [...effects, { type, cardIndex: this.index }]);
     }
+    removeOngoingEffect(type) {
+        this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => !(e.type === type && e.cardIndex === this.index)));
+    }
     get player() {
         return this.item.location.player;
     }
-    get opponent() {
+    get foe() {
         return this.game.players.find((p) => p !== this.player);
     }
-    startEffect() {
-        const pendingEffects = this.remind(Memory.PendingEffects);
-        if (!pendingEffects.length) {
-            pendingEffects.push({ cardIndex: this.index });
-        }
-        const effect = pendingEffects[0];
-        if (effect.challenge) {
-            return [this.startPlayerTurn(RuleId.MayChallenge, this.player)];
-        }
-        else {
-            return [this.startPlayerTurn(this.card, this.player)];
-        }
+    startEffect(effect) {
+        return [this.startPlayerTurn(effect.ruleId, this.getEffectPlayer(effect))];
+    }
+    getEffectPlayer(_effect) {
+        return this.player;
     }
     canBePlayed() {
-        const ongoingEffects = this.remind(Memory.OngoingEffects);
-        const forcedSuit = ongoingEffects.find((e) => e.type === OngoingEffectType.ForcedSuit);
-        if (forcedSuit) {
-            const sourceCard = this.material(MaterialType.Card).getItem(forcedSuit.cardIndex);
-            if (sourceCard.location.player !== this.player) {
-                const forcedSuitValue = cardProperties[sourceCard.id.front].suit;
-                if (this.properties.suit !== forcedSuitValue)
-                    return false;
-            }
-        }
+        return this.canSuitBePlayed() && !this.ongoingEffectPreventsPlayCard();
+    }
+    canSuitBePlayed() {
         const currentSuit = this.remind(Memory.Suit);
         const cardSuit = this.properties.suit;
-        return !(cardSuit === CardSuit.Night && currentSuit === CardSuit.Day) && !(cardSuit === CardSuit.Day && currentSuit === CardSuit.Night);
+        return !currentSuit || cardSuit === CardSuit.Twilight || cardSuit === currentSuit;
     }
-    permanentEffectTag = undefined;
-    hasPermanentEffectOnTag(tag) {
-        return this.permanentEffectTag === tag;
+    ongoingEffectPreventsPlayCard() {
+        const ongoingEffects = this.remind(Memory.OngoingEffects);
+        for (const effect of ongoingEffects) {
+            if (effect.type === OngoingEffectType.PreventPlayCard) {
+                const sourceCardRule = createCardRule(this.game, effect.cardIndex);
+                if (sourceCardRule.preventPlayCard(this.card, this.player)) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
 }

package/dist/material/CardTag.d.ts

@@ -1,5 +1,6 @@
 export declare enum CardTag {
     Knight = 1,
     Archer = 2,
-    Cannon = 3
+    Undead = 3,
+    Cannon = 4
 }

package/dist/material/CardTag.js

@@ -2,5 +2,6 @@ export var CardTag;
 (function (CardTag) {
     CardTag[CardTag["Knight"] = 1] = "Knight";
     CardTag[CardTag["Archer"] = 2] = "Archer";
-    CardTag[CardTag["Cannon"] = 3] = "Cannon";
+    CardTag[CardTag["Undead"] = 3] = "Undead";
+    CardTag[CardTag["Cannon"] = 4] = "Cannon";
 })(CardTag || (CardTag = {}));

package/dist/material/Effect.d.ts

@@ -1,4 +1,4 @@
 export type Effect = {
     cardIndex: number;
-    challenge?: boolean;
+    ruleId: number;
 };

package/dist/material/EffectTraits.d.ts

@@ -0,0 +1,51 @@
+import { Material } from '@gamepark/rules-api';
+import { Card } from './Card';
+import { Deck } from '../Deck';
+export interface DrawEffect {
+    getDrawCount?(): number;
+    getDrawPlayer?(): Deck;
+}
+export interface DiscardEffect {
+    getDiscardCount?(): number;
+    getDiscardTargets?(): Material;
+    isAutoDiscard?(): boolean;
+}
+export interface ReturnCardEffect {
+    getReturnTargets?(): Material;
+    isAutoReturn?(): boolean;
+    isReturnOptional?(): boolean;
+}
+export interface DestroyEffect {
+    getDestroyTargets(): Material;
+    getDestroyCount?(): number;
+    isDestroyOptional?(): boolean;
+    isAutoDestroy?(): boolean;
+}
+export interface PutPowerTokenEffect {
+    getPutPowerTokenTargets?(): Material;
+    getPutPowerTokenCount?(): number;
+    isAutoPutPowerToken?(): boolean;
+}
+export interface StashPowerTokenEffect {
+    getStashPowerTokenCount?(): number;
+}
+export interface PlayCardEffect {
+    getPlayCardTargets?(): Material;
+    isPlayCardOptional?(): boolean;
+}
+export interface ChallengeEffect {
+    onChallengeAccepted?(): void;
+    onChallengeDeclined?(): void;
+}
+export interface StunEffect {
+    getStunTargets?(): Material;
+    getStunCount?(): number;
+    getStunTargetsCount?(): number;
+    isAutoStun?(): boolean;
+}
+export interface PreventPlayCardEffect {
+    preventPlayCard(card: Card, player: Deck): boolean;
+}
+export interface PreventEffectsEffect {
+    preventEnterEffects(cardIndex: number): boolean;
+}

package/dist/material/EffectTraits.js

@@ -0,0 +1 @@
+export {};

package/dist/material/LocationType.d.ts

@@ -10,5 +10,7 @@ export declare enum LocationType {
     PlayerCrystals = 9,
     CardPowerTokens = 10,
     CardStunTokens = 11,
-    PlayerStash = 12
+    PlayerStash = 12,
+    CardSpecialTokens = 13,
+    UnderCard = 14
 }

package/dist/material/LocationType.js

@@ -12,4 +12,6 @@ export var LocationType;
     LocationType[LocationType["CardPowerTokens"] = 10] = "CardPowerTokens";
     LocationType[LocationType["CardStunTokens"] = 11] = "CardStunTokens";
     LocationType[LocationType["PlayerStash"] = 12] = "PlayerStash";
+    LocationType[LocationType["CardSpecialTokens"] = 13] = "CardSpecialTokens";
+    LocationType[LocationType["UnderCard"] = 14] = "UnderCard";
 })(LocationType || (LocationType = {}));

package/dist/material/MaterialType.d.ts

@@ -2,5 +2,6 @@ export declare enum MaterialType {
     Card = 1,
     Crystal = 2,
     PowerToken = 3,
-    StunToken = 4
+    StunToken = 4,
+    SpecialToken = 5
 }

package/dist/material/MaterialType.js

@@ -4,4 +4,5 @@ export var MaterialType;
     MaterialType[MaterialType["Crystal"] = 2] = "Crystal";
     MaterialType[MaterialType["PowerToken"] = 3] = "PowerToken";
     MaterialType[MaterialType["StunToken"] = 4] = "StunToken";
+    MaterialType[MaterialType["SpecialToken"] = 5] = "SpecialToken";
 })(MaterialType || (MaterialType = {}));

package/dist/material/OngoingEffect.d.ts

@@ -1,6 +1,6 @@
 export declare enum OngoingEffectType {
-    ForcedSuit = 1,
-    DeathTrap = 2
+    PreventPlayCard = 1,
+    PreventEffects = 2
 }
 export type OngoingEffect = {
     type: OngoingEffectType;

package/dist/material/OngoingEffect.js

@@ -1,5 +1,5 @@
 export var OngoingEffectType;
 (function (OngoingEffectType) {
-    OngoingEffectType[OngoingEffectType["ForcedSuit"] = 1] = "ForcedSuit";
-    OngoingEffectType[OngoingEffectType["DeathTrap"] = 2] = "DeathTrap";
+    OngoingEffectType[OngoingEffectType["PreventPlayCard"] = 1] = "PreventPlayCard";
+    OngoingEffectType[OngoingEffectType["PreventEffects"] = 2] = "PreventEffects";
 })(OngoingEffectType || (OngoingEffectType = {}));

package/dist/material/SpecialTokenType.d.ts

@@ -0,0 +1,3 @@
+export declare enum SpecialTokenType {
+    Doom = 1
+}

package/dist/material/SpecialTokenType.js

@@ -0,0 +1,4 @@
+export var SpecialTokenType;
+(function (SpecialTokenType) {
+    SpecialTokenType[SpecialTokenType["Doom"] = 1] = "Doom";
+})(SpecialTokenType || (SpecialTokenType = {}));

package/dist/material/createCardRule.d.ts

@@ -0,0 +1,3 @@
+import { MaterialGame } from '@gamepark/rules-api';
+import { CardRule } from './CardRule';
+export declare function createCardRule(game: MaterialGame, cardIndex: number): CardRule;

package/dist/material/createCardRule.js

@@ -0,0 +1,7 @@
+import { cardProperties } from './CardProperties';
+import { MaterialType } from './MaterialType';
+export function createCardRule(game, cardIndex) {
+    const card = game.items[MaterialType.Card][cardIndex].id.front;
+    const Rule = cardProperties[card].rule;
+    return new Rule(game, cardIndex);
+}

package/dist/material/decks/GraveHurt.d.ts

@@ -0,0 +1,18 @@
+export declare const GraveHurt: {
+    301: number;
+    302: number;
+    303: number;
+    304: number;
+    305: number;
+    306: number;
+    307: number;
+    308: number;
+    309: number;
+    310: number;
+    311: number;
+    312: number;
+    313: number;
+    314: number;
+    315: number;
+    316: number;
+};

package/dist/material/decks/GraveHurt.js

@@ -0,0 +1,19 @@
+import { Card } from '../Card';
+export const GraveHurt = {
+    [Card.MacabreLegion]: 2,
+    [Card.CavernSkulker]: 2,
+    [Card.TheGreatToady]: 1,
+    [Card.Umbraboros]: 1,
+    [Card.Nosferatis]: 2,
+    [Card.InsatiableUmbraphage]: 2,
+    [Card.ScrabDoombird]: 1,
+    [Card.MoonFang]: 2,
+    [Card.Whisperers]: 2,
+    [Card.OstraVoiceOfTheSoul]: 1,
+    [Card.TerrifyingSummoning]: 2,
+    [Card.ReturnInTime]: 1,
+    [Card.CallOfTheEclipse]: 1,
+    [Card.WitchingHour]: 2,
+    [Card.Doom]: 1,
+    [Card.AstralHammer]: 1
+};

package/dist/material/decks/WindSands.d.ts

@@ -0,0 +1,18 @@
+export declare const WindSands: {
+    201: number;
+    202: number;
+    203: number;
+    204: number;
+    205: number;
+    206: number;
+    207: number;
+    208: number;
+    209: number;
+    210: number;
+    211: number;
+    212: number;
+    213: number;
+    214: number;
+    215: number;
+    216: number;
+};

package/dist/material/decks/WindSands.js

@@ -0,0 +1,19 @@
+import { Card } from '../Card';
+export const WindSands = {
+    [Card.DesertRaider]: 2,
+    [Card.Metamorph]: 2,
+    [Card.ErgDeathslayer]: 1,
+    [Card.AbiSnakeCharmer]: 1,
+    [Card.Catadjinn]: 2,
+    [Card.Vandals]: 2,
+    [Card.MushaFakir]: 1,
+    [Card.OasisShaman]: 2,
+    [Card.MalikShadowtracker]: 1,
+    [Card.DuneWardrums]: 2,
+    [Card.SandWalkers]: 1,
+    [Card.WishLamp]: 2,
+    [Card.StarlightBazaar]: 1,
+    [Card.AncientCurse]: 1,
+    [Card.WindWrath]: 1,
+    [Card.DeathTrap]: 2
+};

package/dist/material/decks/gravehurt/AstralHammer.d.ts

@@ -0,0 +1,18 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { StunEffect } from '../../EffectTraits';
+declare class AstralHammerRule extends CardRule implements StunEffect {
+    onEnters(): void;
+    getStunTargets(): Material;
+    getStunCount(): number;
+    isAutoStun(): boolean;
+}
+export declare const AstralHammer: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof AstralHammerRule;
+};
+export {};

package/dist/material/decks/gravehurt/AstralHammer.js

@@ -0,0 +1,25 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { createCardRule } from '../../createCardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class AstralHammerRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+    getStunTargets() {
+        return this.creatures.player(this.foe).index((index) => createCardRule(this.game, index).getPower() <= 3);
+    }
+    getStunCount() {
+        return 2;
+    }
+    isAutoStun() {
+        return true;
+    }
+}
+export const AstralHammer = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: AstralHammerRule
+};

package/dist/material/decks/gravehurt/AstralHammerEffectRule.d.ts

@@ -0,0 +1,4 @@
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class AstralHammerEffectRule extends EffectRule {
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/material/decks/gravehurt/AstralHammerEffectRule.js

@@ -0,0 +1,26 @@
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class AstralHammerEffectRule extends EffectRule {
+    onRuleStart() {
+        const targets = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.nextPlayer)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .index((index) => new PlayerHelper(this.game).getCardRule(index).getPower() <= 3);
+        const moves = [];
+        for (const index of targets.getIndexes()) {
+            moves.push(this.material(MaterialType.StunToken).createItem({
+                location: {
+                    type: LocationType.CardStunTokens,
+                    parent: index
+                },
+                quantity: 2
+            }));
+        }
+        return [...moves, ...this.endEffect()];
+    }
+}

package/dist/material/decks/gravehurt/CallOfTheEclipse.d.ts

@@ -0,0 +1,17 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PlayCardEffect } from '../../EffectTraits';
+declare class CallOfTheEclipseRule extends CardRule implements PlayCardEffect {
+    onEnters(): void;
+    getPlayCardTargets(): Material;
+    isPlayCardOptional(): boolean;
+}
+export declare const CallOfTheEclipse: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof CallOfTheEclipseRule;
+};
+export {};

package/dist/material/decks/gravehurt/CallOfTheEclipse.js

@@ -0,0 +1,28 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class CallOfTheEclipseRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.PlayCardEffect);
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    getPlayCardTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerHand)
+            .player(this.player)
+            .id((id) => id.front !== undefined && cardProperties[id.front].suit === CardSuit.Night);
+    }
+    isPlayCardOptional() {
+        return true;
+    }
+}
+export const CallOfTheEclipse = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: CallOfTheEclipseRule
+};

package/dist/material/decks/gravehurt/CallOfTheEclipseEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class CallOfTheEclipseEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+}

package/dist/material/decks/gravehurt/CallOfTheEclipseEffectRule.js

@@ -0,0 +1,11 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { EffectRule } from '../../../rules/EffectRule';
+import { EffectType } from '../../Effect';
+export class CallOfTheEclipseEffectRule extends EffectRule {
+    onRuleStart() {
+        this.cardRule.addPendingEffect(EffectType.ChallengeAccepted);
+        const moves = this.endEffect();
+        moves.unshift(this.customMove(CustomMoveType.Draw, { player: this.player, quantity: 1 }));
+        return moves;
+    }
+}

package/dist/material/decks/gravehurt/CavernSkulker.d.ts

@@ -0,0 +1,16 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { UndeadRule } from './UndeadRule';
+declare class CavernSkulkerRule extends UndeadRule {
+    onEnters(): void;
+    onLeaves(): import("@gamepark/rules-api").MaterialMove[];
+}
+export declare const CavernSkulker: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag: CardTag;
+    rule: typeof CavernSkulkerRule;
+};
+export {};

package/dist/material/decks/gravehurt/CavernSkulker.js

@@ -0,0 +1,26 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { UndeadRule } from './UndeadRule';
+class CavernSkulkerRule extends UndeadRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.CavernSkulkerEffect);
+    }
+    onLeaves() {
+        const underCards = this.material(MaterialType.Card).location(LocationType.UnderCard).parent(this.index);
+        return [
+            ...underCards.moveItems((item) => ({ type: LocationType.PlayerHand, player: item.id.back })),
+            ...super.onLeaves()
+        ];
+    }
+}
+export const CavernSkulker = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    tag: CardTag.Undead,
+    rule: CavernSkulkerRule
+};

package/dist/material/decks/gravehurt/CavernSkulkerEffectRule.d.ts

@@ -0,0 +1,4 @@
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class CavernSkulkerEffectRule extends EffectRule {
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/material/decks/gravehurt/CavernSkulkerEffectRule.js

@@ -0,0 +1,15 @@
+import { sample } from 'es-toolkit';
+import { EffectRule } from '../../../rules/EffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class CavernSkulkerEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = this.endEffect();
+        const foeHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.nextPlayer);
+        if (foeHand.length > 0) {
+            const randomIndex = sample(foeHand.getIndexes());
+            moves.unshift(foeHand.index(randomIndex).moveItem({ type: LocationType.UnderCard, parent: this.effectCardIndex }));
+        }
+        return moves;
+    }
+}

package/dist/material/decks/gravehurt/Doom.d.ts

@@ -0,0 +1,18 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class DoomRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    onLeaves(): import("@gamepark/rules-api").MaterialMove[];
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const Doom: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DoomRule;
+};
+export {};