@gamepark/skyrift 0.4.2 → 0.5.0

package/dist/material/decks/blackhive/CycleKeeperEffectRule.d.ts

@@ -0,0 +1,6 @@
+import { CustomMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class CycleKeeperEffectRule extends EffectRule {
+    getPlayerMoves(): CustomMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/material/decks/blackhive/CycleKeeperEffectRule.js

@@ -0,0 +1,21 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { CardSuit } from '../../CardSuit';
+import { OngoingEffectType } from '../../OngoingEffect';
+import { EffectRule } from '../../../rules/EffectRule';
+export class CycleKeeperEffectRule extends EffectRule {
+    getPlayerMoves() {
+        return [
+            this.customMove(CustomMoveType.ChooseSuit, CardSuit.Day),
+            this.customMove(CustomMoveType.ChooseSuit, CardSuit.Night)
+        ];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseSuit) {
+            this.memorize(Memory.Suit, move.data);
+            this.cardRule.addOngoingEffect(OngoingEffectType.LockSuit);
+            return this.endEffect();
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/material/decks/blackhive/DariusAstraSmith.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class DariusAstraSmithRule extends CardRule {
+    onEnters(): void;
+}
+export declare const DariusAstraSmith: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DariusAstraSmithRule;
+};
+export {};

package/dist/material/decks/blackhive/DariusAstraSmith.js

@@ -0,0 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class DariusAstraSmithRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.MulliganEffect);
+    }
+}
+export const DariusAstraSmith = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: DariusAstraSmithRule
+};

package/dist/material/decks/blackhive/DarkSwarm.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class DarkSwarmRule extends CardRule {
+    onEnters(): void;
+}
+export declare const DarkSwarm: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DarkSwarmRule;
+};
+export {};

package/dist/material/decks/blackhive/DarkSwarm.js

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class DarkSwarmRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PassTurn);
+    }
+}
+export const DarkSwarm = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: DarkSwarmRule
+};

package/dist/material/decks/blackhive/DarkSwarmEffectRule.d.ts

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

package/dist/material/decks/blackhive/DarkSwarmEffectRule.js

@@ -0,0 +1,18 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { RuleId } from '../../../rules/RuleId';
+export class DarkSwarmEffectRule extends EffectRule {
+    onRuleStart() {
+        return this.endEffect();
+    }
+    onEndEffect() {
+        this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        if (pendingEffects.length > 0) {
+            return new PlayerHelper(this.game, this.player).startEffect(pendingEffects[0]);
+        }
+        const currentPlayer = this.remind(Memory.CurrentPlayer);
+        return [this.startPlayerTurn(RuleId.EndPlayerTurn, currentPlayer)];
+    }
+}

package/dist/material/decks/blackhive/ElevatorOfTheAbyss.d.ts

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { ReturnCardEffect } from '../../EffectTraits';
+declare class ElevatorOfTheAbyssRule extends CardRule implements ReturnCardEffect {
+    onEnters(): void;
+    getReturnTargets(): import("@gamepark/rules-api").Material<number, number, number>;
+}
+export declare const ElevatorOfTheAbyss: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof ElevatorOfTheAbyssRule;
+};
+export {};

package/dist/material/decks/blackhive/ElevatorOfTheAbyss.js

@@ -0,0 +1,19 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ElevatorOfTheAbyssRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    getReturnTargets() {
+        return this.creatures.player(this.player);
+    }
+}
+export const ElevatorOfTheAbyss = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: ElevatorOfTheAbyssRule
+};

package/dist/material/decks/blackhive/ExplosiveKitty.d.ts

@@ -0,0 +1,16 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class ExplosiveKittyRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    getDestroyTargets(): Material;
+}
+export declare const ExplosiveKitty: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof ExplosiveKittyRule;
+};
+export {};

package/dist/material/decks/blackhive/ExplosiveKitty.js

@@ -0,0 +1,19 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ExplosiveKittyRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        return this.playArea.id((id) => cardProperties[id.front].type === CardType.Action);
+    }
+}
+export const ExplosiveKitty = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: ExplosiveKittyRule
+};

package/dist/material/decks/blackhive/GromIronspike.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class GromIronspikeRule extends CardRule {
+    canBePlayed(): boolean;
+}
+export declare const GromIronspike: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof GromIronspikeRule;
+};
+export {};

package/dist/material/decks/blackhive/GromIronspike.js

@@ -0,0 +1,18 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+class GromIronspikeRule extends CardRule {
+    canBePlayed() {
+        if (!super.canBePlayed())
+            return false;
+        const foePower = new PlayerHelper(this.game, this.foe).getPower();
+        return foePower >= 12;
+    }
+}
+export const GromIronspike = {
+    power: 7,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: GromIronspikeRule
+};

package/dist/material/decks/blackhive/GuntarRustypike.d.ts

@@ -0,0 +1,20 @@
+import { Material } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class GuntarRustypikeRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    onCardEnters(card: Card, side: Deck): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const GuntarRustypike: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof GuntarRustypikeRule;
+};
+export {};

package/dist/material/decks/blackhive/GuntarRustypike.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 { MaterialType } from '../../MaterialType';
+class GuntarRustypikeRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    onCardEnters(card, side) {
+        if (side === this.foe && cardProperties[card].type === CardType.Action) {
+            this.addPendingEffect(RuleId.DestroyEffect);
+        }
+    }
+    getDestroyTargets() {
+        return this.material(MaterialType.Card).index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const GuntarRustypike = {
+    power: 5,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: GuntarRustypikeRule
+};

package/dist/material/decks/blackhive/HiveMother.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class HiveMotherRule extends CardRule {
+    canBePlayed(): boolean;
+}
+export declare const HiveMother: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof HiveMotherRule;
+};
+export {};

package/dist/material/decks/blackhive/HiveMother.js

@@ -0,0 +1,18 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+class HiveMotherRule extends CardRule {
+    canBePlayed() {
+        if (!super.canBePlayed())
+            return false;
+        const foePower = new PlayerHelper(this.game, this.foe).getPower();
+        return foePower >= 7;
+    }
+}
+export const HiveMother = {
+    power: 4,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: HiveMotherRule
+};

package/dist/material/decks/blackhive/LotharBlackclaw.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class LotharBlackclawRule extends CardRule {
+    onEnters(): void;
+}
+export declare const LotharBlackclaw: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof LotharBlackclawRule;
+};
+export {};

package/dist/material/decks/blackhive/LotharBlackclaw.js

@@ -0,0 +1,22 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { createCardRule } from '../../createCardRule';
+class LotharBlackclawRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+        const creatures = this.creatures.player(this.player);
+        for (const index of creatures.getIndexes()) {
+            if (index !== this.index) {
+                createCardRule(this.game, index).onEnters?.();
+            }
+        }
+    }
+}
+export const LotharBlackclaw = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: LotharBlackclawRule
+};

package/dist/material/decks/blackhive/LotharBlackclawEffectRule.d.ts

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

package/dist/material/decks/blackhive/LotharBlackclawEffectRule.js

@@ -0,0 +1,20 @@
+import { cardProperties } from '../../CardProperties';
+import { createCardRule } from '../../createCardRule';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { EffectRule } from '../../../rules/EffectRule';
+export class LotharBlackclawEffectRule extends EffectRule {
+    onRuleStart() {
+        const creatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        for (const index of creatures.getIndexes()) {
+            if (index !== this.effectCardIndex) {
+                createCardRule(this.game, index).onEnters?.();
+            }
+        }
+        return this.endEffect();
+    }
+}

package/dist/material/decks/blackhive/OlgaStonecrusher.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class OlgaStonecrusherRule extends CardRule {
+    onEnters(): void;
+}
+export declare const OlgaStonecrusher: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof OlgaStonecrusherRule;
+};
+export {};

package/dist/material/decks/blackhive/OlgaStonecrusher.js

@@ -0,0 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class OlgaStonecrusherRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+}
+export const OlgaStonecrusher = {
+    power: 4,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: OlgaStonecrusherRule
+};

package/dist/material/decks/blackhive/ShadowDealer.d.ts

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DrawEffect } from '../../EffectTraits';
+declare class ShadowDealerRule extends CardRule implements DrawEffect {
+    onEnters(): void;
+    getDrawCount(): 1 | 0;
+}
+export declare const ShadowDealer: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof ShadowDealerRule;
+};
+export {};

package/dist/material/decks/blackhive/ShadowDealer.js

@@ -0,0 +1,22 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class ShadowDealerRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        const myHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.player).length;
+        const foeHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.foe).length;
+        return myHand < foeHand ? 1 : 0;
+    }
+}
+export const ShadowDealer = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: ShadowDealerRule
+};

package/dist/material/decks/blackhive/UndergroundScourge.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class UndergroundScourgeRule extends CardRule {
+    onEnters(): void;
+}
+export declare const UndergroundScourge: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof UndergroundScourgeRule;
+};
+export {};

package/dist/material/decks/blackhive/UndergroundScourge.js

@@ -0,0 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class UndergroundScourgeRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.StashPowerTokensEffect);
+    }
+}
+export const UndergroundScourge = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: UndergroundScourgeRule
+};

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

@@ -1,10 +1,13 @@
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
+import { ReturnCardEffect } from '../../EffectTraits';
 import { UndeadRule } from './UndeadRule';
-declare class CavernSkulkerRule extends UndeadRule {
+declare class CavernSkulkerRule extends UndeadRule implements ReturnCardEffect {
     onEnters(): void;
     onLeaves(): import("@gamepark/rules-api").MaterialMove[];
+    getReturnTargets(): import("@gamepark/rules-api").Material<number, number, number>;
+    isAutoReturn(): boolean;
 }
 export declare const CavernSkulker: {
     power: number;

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

@@ -1,3 +1,4 @@
+import { Memory } from '../../../Memory';
 import { RuleId } from '../../../rules/RuleId';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
@@ -10,11 +11,23 @@ class CavernSkulkerRule extends UndeadRule {
         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()
-        ];
+        if (this.remind(Memory.PendingEffects).length > 0) {
+            this.addPendingEffect(RuleId.ReturnCardEffect);
+            return super.onLeaves();
+        }
+        else {
+            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()
+            ];
+        }
+    }
+    getReturnTargets() {
+        return this.material(MaterialType.Card).location(LocationType.UnderCard).parent(this.index);
+    }
+    isAutoReturn() {
+        return true;
     }
 }
 export const CavernSkulker = {

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

@@ -1,9 +1,13 @@
+import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class DoomRule extends CardRule {
+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;

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

@@ -1,3 +1,4 @@
+import { Memory } from '../../../Memory';
 import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
@@ -10,9 +11,22 @@ class DoomRule extends CardRule {
         this.addPendingEffect(RuleId.DoomEffect);
     }
     onLeaves() {
+        if (this.remind(Memory.PendingEffects).length > 0) {
+            this.addPendingEffect(RuleId.DestroyEffect);
+            return super.onLeaves();
+        }
+        else {
+            const doomTokens = this.material(MaterialType.SpecialToken).id(SpecialTokenType.Doom).location(LocationType.CardSpecialTokens);
+            const doomedIndexes = doomTokens.getItems().map((item) => item.location.parent);
+            return [...this.playArea.index(doomedIndexes).moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back })), ...super.onLeaves()];
+        }
+    }
+    getDestroyTargets() {
         const doomTokens = this.material(MaterialType.SpecialToken).id(SpecialTokenType.Doom).location(LocationType.CardSpecialTokens);
-        const doomedIndexes = doomTokens.getItems().map((item) => item.location.parent);
-        return [...this.playArea.index(doomedIndexes).moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back })), ...super.onLeaves()];
+        return this.playArea.index((index) => doomTokens.parent(index).length > 0);
+    }
+    isAutoDestroy() {
+        return true;
     }
 }
 export const Doom = {

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

@@ -1,11 +1,11 @@
 import { Material } from '@gamepark/rules-api';
 import { Deck } from '../../../Deck';
 import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 import { DestroyEffect } from '../../EffectTraits';
-import { UndeadRule } from './UndeadRule';
-declare class NosferatisRule extends UndeadRule implements DestroyEffect {
+declare class NosferatisRule extends CardRule implements DestroyEffect {
     getPowerIfNotStunned(): number;
     onCardEnters(card: Card, side: Deck): void;
     getDestroyTargets(): Material;

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

@@ -1,10 +1,10 @@
 import { RuleId } from '../../../rules/RuleId';
 import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 import { MaterialType } from '../../MaterialType';
-import { UndeadRule } from './UndeadRule';
-class NosferatisRule extends UndeadRule {
+class NosferatisRule extends CardRule {
     getPowerIfNotStunned() {
         const foeCreatures = this.creatures.player(this.foe);
         return super.getPowerIfNotStunned() + foeCreatures.length;

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

@@ -1,9 +1,9 @@
 import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 import { DiscardEffect, ReturnCardEffect } from '../../EffectTraits';
-import { UndeadRule } from './UndeadRule';
-declare class TheGreatToadyRule extends UndeadRule implements DiscardEffect, ReturnCardEffect {
+declare class TheGreatToadyRule extends CardRule implements DiscardEffect, ReturnCardEffect {
     activate(): void;
     canDraw(): boolean;
     getDiscardTargets(): Material;

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

@@ -1,12 +1,12 @@
 import { RuleId } from '../../../rules/RuleId';
 import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
 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 TheGreatToadyRule extends UndeadRule {
+class TheGreatToadyRule extends CardRule {
     activate() {
         if (this.canDraw()) {
             this.addPendingEffect(RuleId.DrawEffect);

package/dist/material/decks/heathblade/Armada.js

@@ -7,7 +7,7 @@ class ArmadaRule extends CardRule {
         this.addPendingEffect(RuleId.ChallengeEffect);
     }
     onChallengeAccepted() {
-        this.addPendingEffect(RuleId.ArmadaEffect);
+        this.addPendingEffect(RuleId.MulliganEffect);
     }
 }
 export const Armada = {