@gamepark/skyrift 0.2.9 → 0.4.0

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 {};

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

@@ -0,0 +1,29 @@
+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';
+import { SpecialTokenType } from '../../SpecialTokenType';
+class DoomRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DoomEffect);
+    }
+    onLeaves() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+        return super.onLeaves();
+    }
+    getDestroyTargets() {
+        const doomTokens = this.material(MaterialType.SpecialToken).id(SpecialTokenType.Doom).location(LocationType.CardSpecialTokens);
+        return this.playArea.index((index) => doomTokens.parent(index).length > 0);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const Doom = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: DoomRule
+};

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

@@ -0,0 +1,8 @@
+import { ItemMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class DoomEffectRule extends EffectRule {
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+    getPlayerMoves(): import("@gamepark/rules-api").CreateItem<number, number, number>[];
+    get creatures(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+}

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

@@ -0,0 +1,32 @@
+import { isCreateItemType } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { SpecialTokenType } from '../../SpecialTokenType';
+export class DoomEffectRule extends EffectRule {
+    onRuleStart() {
+        if (!this.creatures.length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.creatures.getIndexes().map((index) => this.material(MaterialType.SpecialToken).createItem({
+            id: SpecialTokenType.Doom,
+            location: { type: LocationType.CardSpecialTokens, parent: index }
+        }));
+    }
+    get creatures() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.SpecialToken)(move)) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

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

@@ -0,0 +1,19 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { DestroyEffect, PutPowerTokenEffect } from '../../EffectTraits';
+import { UndeadRule } from './UndeadRule';
+declare class InsatiableUmbraphageRule extends UndeadRule implements DestroyEffect, PutPowerTokenEffect {
+    canActivate(): boolean;
+    activate(): void;
+    getDestroyTargets(): import("@gamepark/rules-api").Material<number, number, number>;
+    isAutoPutPowerToken(): boolean;
+}
+export declare const InsatiableUmbraphage: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag: CardTag;
+    rule: typeof InsatiableUmbraphageRule;
+};
+export {};

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

@@ -0,0 +1,28 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { UndeadRule } from './UndeadRule';
+class InsatiableUmbraphageRule extends UndeadRule {
+    canActivate() {
+        return super.canActivate() && this.getDestroyTargets().length > 0;
+    }
+    activate() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+        this.addPendingEffect(RuleId.PutPowerTokensEffect);
+    }
+    getDestroyTargets() {
+        return this.playArea.id((id) => cardProperties[id.front].type === CardType.Action);
+    }
+    isAutoPutPowerToken() {
+        return true;
+    }
+}
+export const InsatiableUmbraphage = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    tag: CardTag.Undead,
+    rule: InsatiableUmbraphageRule
+};

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

@@ -0,0 +1,5 @@
+import { ItemMove } from '@gamepark/rules-api';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+export declare class InsatiableUmbraphageEffectRule extends DestroyEffectRule {
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+}

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

@@ -0,0 +1,21 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class InsatiableUmbraphageEffectRule extends DestroyEffectRule {
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
+            return [
+                this.material(MaterialType.PowerToken).createItem({
+                    location: {
+                        type: LocationType.CardPowerTokens,
+                        parent: this.effectCardIndex
+                    },
+                    quantity: 1
+                }),
+                ...this.endEffect()
+            ];
+        }
+        return [];
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ReturnCardEffect } from '../../EffectTraits';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { UndeadRule } from './UndeadRule';
+declare class MacabreLegionRule extends UndeadRule implements ReturnCardEffect {
+    onSkirmishLost(): void;
+    isAutoReturn(): boolean;
+}
+export declare const MacabreLegion: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag: CardTag;
+    rule: typeof MacabreLegionRule;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { UndeadRule } from './UndeadRule';
+class MacabreLegionRule extends UndeadRule {
+    onSkirmishLost() {
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+    }
+    isAutoReturn() {
+        return true;
+    }
+}
+export const MacabreLegion = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    tag: CardTag.Undead,
+    rule: MacabreLegionRule
+};

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

@@ -0,0 +1,17 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { PutPowerTokenEffect } from '../../EffectTraits';
+import { UndeadRule } from './UndeadRule';
+declare class MoonFangRule extends UndeadRule implements PutPowerTokenEffect {
+    onPlayerTurnStart(): void;
+    isAutoPutPowerToken(): boolean;
+}
+export declare const MoonFang: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag: CardTag;
+    rule: typeof MoonFangRule;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { UndeadRule } from './UndeadRule';
+class MoonFangRule extends UndeadRule {
+    onPlayerTurnStart() {
+        this.addPendingEffect(RuleId.PutPowerTokensEffect);
+    }
+    isAutoPutPowerToken() {
+        return true;
+    }
+}
+export const MoonFang = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    tag: CardTag.Undead,
+    rule: MoonFangRule
+};

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

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

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

@@ -0,0 +1,29 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { MaterialType } from '../../MaterialType';
+import { UndeadRule } from './UndeadRule';
+class NosferatisRule extends UndeadRule {
+    getPowerIfNotStunned() {
+        const foeCreatures = this.creatures.player(this.foe);
+        return super.getPowerIfNotStunned() + foeCreatures.length;
+    }
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].suit === CardSuit.Day) {
+            this.addPendingEffect(RuleId.DestroyEffect);
+        }
+    }
+    getDestroyTargets() {
+        return this.material(MaterialType.Card).index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const Nosferatis = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: NosferatisRule
+};

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

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class OstraVoiceOfTheSoulRule extends CardRule {
+}
+export declare const OstraVoiceOfTheSoul: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof OstraVoiceOfTheSoulRule;
+};
+export {};

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

@@ -0,0 +1,11 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class OstraVoiceOfTheSoulRule extends CardRule {
+}
+export const OstraVoiceOfTheSoul = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: OstraVoiceOfTheSoulRule
+};

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { Material } from '@gamepark/rules-api';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { ReturnCardEffect } from '../../EffectTraits';
+import { UndeadRule } from './UndeadRule';
+declare class ScrabDoombirdRule extends UndeadRule implements ReturnCardEffect {
+    onEnters(): void;
+    getReturnTargets(): Material;
+}
+export declare const ScrabDoombird: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag: CardTag;
+    rule: typeof ScrabDoombirdRule;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { UndeadRule } from './UndeadRule';
+class ScrabDoombirdRule extends UndeadRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+    }
+    getReturnTargets() {
+        return this.playArea.id((id) => cardProperties[id.front].type === CardType.Action);
+    }
+}
+export const ScrabDoombird = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    tag: CardTag.Undead,
+    rule: ScrabDoombirdRule
+};

package/dist/material/decks/gravehurt/TerrifyingSummoning.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 TerrifyingSummoningRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    onFoeTurnStart(): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const TerrifyingSummoning: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof TerrifyingSummoningRule;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { MaterialType } from '../../MaterialType';
+class TerrifyingSummoningRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    onFoeTurnStart() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        return this.material(MaterialType.Card).index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const TerrifyingSummoning = {
+    power: 6,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: TerrifyingSummoningRule
+};

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

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

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

@@ -0,0 +1,11 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { EffectRule } from '../../../rules/EffectRule';
+import { EffectType } from '../../Effect';
+export class TerrifyingSummoningEffectRule 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/TheGreatToady.d.ts

@@ -0,0 +1,19 @@
+import { Material } from '@gamepark/rules-api';
+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 {
+    activate(): void;
+    canDraw(): boolean;
+    getDiscardTargets(): Material;
+    isAutoDiscard(): boolean;
+    getReturnTargets(): Material;
+}
+export declare const TheGreatToady: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof TheGreatToadyRule;
+};
+export {};

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

@@ -0,0 +1,42 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+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 {
+    activate() {
+        if (this.canDraw()) {
+            this.addPendingEffect(RuleId.DrawEffect);
+            this.addPendingEffect(RuleId.DiscardEffect);
+        }
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+    }
+    canDraw() {
+        const playerCards = this.material(MaterialType.Card).player(this.player);
+        return playerCards.location(LocationType.PlayerDeck).length > 0 || playerCards.location(LocationType.PlayerDiscard).length > 0;
+    }
+    getDiscardTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerHand)
+            .player(this.player)
+            .maxBy((item) => item.location.x);
+    }
+    isAutoDiscard() {
+        return true;
+    }
+    getReturnTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerDiscard)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].tag === CardTag.Undead);
+    }
+}
+export const TheGreatToady = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: TheGreatToadyRule
+};

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

@@ -0,0 +1,22 @@
+import { Material } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+import { UndeadRule } from './UndeadRule';
+declare class UmbraborosRule extends UndeadRule implements DestroyEffect {
+    onCardEnters(card: Card, side: Deck): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+    survivesSkirmish(): boolean;
+}
+export declare const Umbraboros: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag: CardTag;
+    rule: typeof UmbraborosRule;
+};
+export {};

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

@@ -0,0 +1,30 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { MaterialType } from '../../MaterialType';
+import { UndeadRule } from './UndeadRule';
+class UmbraborosRule extends UndeadRule {
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].suit === CardSuit.Day) {
+            this.addPendingEffect(RuleId.DestroyEffect);
+        }
+    }
+    getDestroyTargets() {
+        return this.material(MaterialType.Card).index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+    survivesSkirmish() {
+        return true;
+    }
+}
+export const Umbraboros = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    tag: CardTag.Undead,
+    rule: UmbraborosRule
+};

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

@@ -0,0 +1,5 @@
+import { CardRule } from '../../CardRule';
+export declare class UndeadRule extends CardRule {
+    canSuitBePlayed(): boolean;
+    get hasOstraVoiceOfTheSoul(): boolean;
+}

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

@@ -0,0 +1,11 @@
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+export class UndeadRule extends CardRule {
+    canSuitBePlayed() {
+        return super.canSuitBePlayed() || this.hasOstraVoiceOfTheSoul;
+    }
+    get hasOstraVoiceOfTheSoul() {
+        return new PlayerHelper(this.game, this.player).hasCard(Card.OstraVoiceOfTheSoul);
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class WhisperersRule extends CardRule {
+    getPowerIfNotStunned() {
+        const foeCrystals = this.material(MaterialType.Crystal).location(LocationType.PlayerCrystals).player(this.foe).getQuantity();
+        return super.getPowerIfNotStunned() + foeCrystals;
+    }
+}
+export const Whisperers = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: WhisperersRule
+};