@gamepark/skyrift 0.2.8 → 0.3.0

package/dist/material/decks/highwave/BonnyTheGunner.d.ts

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+declare class BonnyTheGunnerRule extends CardRule {
+    permanentEffectTag: CardTag;
+}
+export declare const BonnyTheGunner: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof BonnyTheGunnerRule;
+};
+export {};

package/dist/material/decks/highwave/BonnyTheGunner.js

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+class BonnyTheGunnerRule extends CardRule {
+    permanentEffectTag = CardTag.Cannon;
+}
+export const BonnyTheGunner = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: BonnyTheGunnerRule
+};

package/dist/material/decks/highwave/CannonCardRule.js

@@ -2,13 +2,15 @@ import { Memory } from '../../../Memory';
 import { PlayerHelper } from '../../../rules/PlayerHelper';
 import { cardProperties } from '../../CardProperties';
 import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { MaterialType } from '../../MaterialType';
 export class CannonCardRule extends CardRule {
     canBePlayed() {
-        const hasMistyGunner = new PlayerHelper(this.game, this.player).cardRules.some((rule) => rule.hasPermanentEffectOnTag(CardTag.Cannon));
-        if (hasMistyGunner) {
-            return true;
+        const hasBonnyTheGunner = new PlayerHelper(this.game, this.player).cardRules.some((rule) => rule.hasPermanentEffectOnTag(CardTag.Cannon));
+        if (hasBonnyTheGunner) {
+            const currentSuit = this.remind(Memory.Suit);
+            return this.properties.suit !== CardSuit.Day || currentSuit !== CardSuit.Night;
         }
         const hasPlayedCannon = this.remind(Memory.CardsPlayed, this.player).some((cardIndex) => cardProperties[this.material(MaterialType.Card).getItem(cardIndex).id.front].tag === CardTag.Cannon);
         if (hasPlayedCannon) {

package/dist/material/decks/highwave/DarkArmageddon.d.ts

@@ -0,0 +1,15 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+declare class DarkArmageddonRule extends CannonCardRule {
+    entersEffect: boolean;
+}
+export declare const DarkArmageddon: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof DarkArmageddonRule;
+};
+export {};

package/dist/material/decks/highwave/DarkArmageddon.js

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+class DarkArmageddonRule extends CannonCardRule {
+    entersEffect = true;
+}
+export const DarkArmageddon = {
+    power: 2,
+    type: CardType.Action,
+    tag: CardTag.Cannon,
+    suit: CardSuit.Night,
+    rule: DarkArmageddonRule
+};

package/dist/material/decks/highwave/DarkArmageddonEffectRule.d.ts

@@ -0,0 +1,4 @@
+import { StunCardRule } from '../../../rules/StunCardRule';
+export declare class DarkArmageddonEffectRule extends StunCardRule {
+    stunCount: number;
+}

package/dist/material/decks/highwave/DarkArmageddonEffectRule.js

@@ -0,0 +1,4 @@
+import { StunCardRule } from '../../../rules/StunCardRule';
+export class DarkArmageddonEffectRule extends StunCardRule {
+    stunCount = 3;
+}

package/dist/material/decks/highwave/EyeOfSky.d.ts

@@ -0,0 +1,16 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class EyeOfSkyRule extends CardRule {
+    onPlayerTurnStart(player: Deck): MaterialMove[];
+    startEffect(): import("@gamepark/rules-api").StartPlayerTurn<number, import("../../Card").Card>[];
+}
+export declare const EyeOfSky: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof EyeOfSkyRule;
+};
+export {};

package/dist/material/decks/highwave/EyeOfSky.js

@@ -0,0 +1,20 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class EyeOfSkyRule extends CardRule {
+    onPlayerTurnStart(player) {
+        if (player !== this.player) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+    startEffect() {
+        return [this.startPlayerTurn(this.card, this.opponent)];
+    }
+}
+export const EyeOfSky = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: EyeOfSkyRule
+};

package/dist/material/decks/highwave/EyeOfSkyEffectRule.d.ts

@@ -0,0 +1,7 @@
+import { CustomMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
+export declare class EyeOfSkyEffectRule extends DiscardEffectRule {
+    getPlayerMoves(): MaterialMove[];
+    onDiscard(move: MoveItem): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+}

package/dist/material/decks/highwave/EyeOfSkyEffectRule.js

@@ -0,0 +1,21 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
+import { RuleId } from '../../../rules/RuleId';
+export class EyeOfSkyEffectRule extends DiscardEffectRule {
+    getPlayerMoves() {
+        return [...super.getPlayerMoves(), this.customMove(CustomMoveType.ConcedeRound)];
+    }
+    onDiscard(move) {
+        this.memorize(Memory.CardsPlayed, (cards) => [...cards, move.itemIndex], this.player);
+        return [this.customMove(CustomMoveType.Draw, { player: this.player, quantity: 1 }), ...this.endEffect()];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ConcedeRound) {
+            return [this.customMove(CustomMoveType.EndEffect), this.startRule(RuleId.EndRound)];
+        }
+        else {
+            return super.onCustomMove(move);
+        }
+    }
+}

package/dist/material/decks/highwave/FortunesCourse.d.ts

@@ -0,0 +1,14 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class FortunesCourseRule extends CardRule {
+    onWinRound(): MaterialMove[];
+}
+export declare const FortunesCourse: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof FortunesCourseRule;
+};
+export {};

package/dist/material/decks/highwave/FortunesCourse.js

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class FortunesCourseRule extends CardRule {
+    onWinRound() {
+        this.addPendingEffect();
+        return [];
+    }
+}
+export const FortunesCourse = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: FortunesCourseRule
+};

package/dist/material/decks/highwave/GoldenApocalypse.d.ts

@@ -0,0 +1,15 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+declare class GoldenApocalypseRule extends CannonCardRule {
+    challenge: boolean;
+}
+export declare const GoldenApocalypse: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof GoldenApocalypseRule;
+};
+export {};

package/dist/material/decks/highwave/GoldenApocalypse.js

@@ -0,0 +1,14 @@
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { CannonCardRule } from './CannonCardRule';
+class GoldenApocalypseRule extends CannonCardRule {
+    challenge = true;
+}
+export const GoldenApocalypse = {
+    power: 5,
+    type: CardType.Action,
+    tag: CardTag.Cannon,
+    suit: CardSuit.Day,
+    rule: GoldenApocalypseRule
+};

package/dist/material/decks/highwave/OscarScullion.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class OscarScullionRule extends CardRule {
+    oncePerTurnEffect: boolean;
+}
+export declare const OscarScullion: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof OscarScullionRule;
+};
+export {};

package/dist/material/decks/highwave/OscarScullion.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class OscarScullionRule extends CardRule {
+    oncePerTurnEffect = true;
+}
+export const OscarScullion = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: OscarScullionRule
+};

package/dist/material/decks/highwave/OscarScullionEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { Material } from '@gamepark/rules-api';
+import { PutPowerTokenEffectRule } from '../../../rules/PutPowerTokenEffectRule';
+export declare class OscarScullionEffectRule extends PutPowerTokenEffectRule {
+    getTargets(): Material;
+}

package/dist/material/decks/highwave/OscarScullionEffectRule.js

@@ -0,0 +1,12 @@
+import { PutPowerTokenEffectRule } from '../../../rules/PutPowerTokenEffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class OscarScullionEffectRule extends PutPowerTokenEffectRule {
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+    }
+}

package/dist/material/decks/highwave/OttoFactotum.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class OttoFactotumRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const OttoFactotum: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof OttoFactotumRule;
+};
+export {};

package/dist/material/decks/highwave/OttoFactotum.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class OttoFactotumRule extends CardRule {
+    entersEffect = true;
+}
+export const OttoFactotum = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: OttoFactotumRule
+};

package/dist/material/decks/highwave/OttoFactotumEffectRule.d.ts

@@ -0,0 +1,4 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+export declare class OttoFactotumEffectRule extends DrawEffectRule {
+    getDrawCount(): number;
+}

package/dist/material/decks/highwave/OttoFactotumEffectRule.js

@@ -0,0 +1,9 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class OttoFactotumEffectRule extends DrawEffectRule {
+    getDrawCount() {
+        const cardsInHands = this.material(MaterialType.Card).location(LocationType.PlayerHand);
+        return cardsInHands.player(this.nextPlayer).length - cardsInHands.player(this.player).length;
+    }
+}

package/dist/material/decks/highwave/RiggingRaiders.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class RiggingRaidersRule extends CardRule {
+    oncePerTurnEffect: boolean;
+}
+export declare const RiggingRaiders: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof RiggingRaidersRule;
+};
+export {};

package/dist/material/decks/highwave/RiggingRaiders.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class RiggingRaidersRule extends CardRule {
+    oncePerTurnEffect = true;
+}
+export const RiggingRaiders = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: RiggingRaidersRule
+};

package/dist/material/decks/highwave/RiggingRaidersEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { Material } from '@gamepark/rules-api';
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+export declare class RiggingRaidersEffectRule extends DestroyEffectRule {
+    getTargets(): Material;
+}

package/dist/material/decks/highwave/RiggingRaidersEffectRule.js

@@ -0,0 +1,17 @@
+import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class RiggingRaidersEffectRule extends DestroyEffectRule {
+    getTargets() {
+        const helper = new PlayerHelper(this.game);
+        const scallywagPower = this.cardRule.getPower();
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(helper.foe)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .index((index) => helper.getCardRule(index).getPower() < scallywagPower);
+    }
+}

package/dist/material/decks/highwave/SeaScorcher.d.ts

@@ -0,0 +1,16 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class SeaScorcherRule extends CardRule {
+    onCardEnters(card: Card, side: Deck): MaterialMove[];
+}
+export declare const SeaScorcher: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof SeaScorcherRule;
+};
+export {};

package/dist/material/decks/highwave/SeaScorcher.js

@@ -0,0 +1,19 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+class SeaScorcherRule extends CardRule {
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].tag === CardTag.Cannon) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+}
+export const SeaScorcher = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: SeaScorcherRule
+};

package/dist/material/decks/highwave/SeaScorcherEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { Material } from '@gamepark/rules-api';
+import { ReturnCardRule } from '../../../rules/ReturnCardRule';
+export declare class SeaScorcherEffectRule extends ReturnCardRule {
+    getTargets(): Material;
+}

package/dist/material/decks/highwave/SeaScorcherEffectRule.js

@@ -0,0 +1,13 @@
+import { ReturnCardRule } from '../../../rules/ReturnCardRule';
+import { cardProperties } from '../../CardProperties';
+import { CardTag } from '../../CardTag';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class SeaScorcherEffectRule extends ReturnCardRule {
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerDiscard)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].tag === CardTag.Cannon);
+    }
+}

package/dist/material/decks/highwave/TideRover.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class TideRoverRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const TideRover: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof TideRoverRule;
+};
+export {};

package/dist/material/decks/highwave/TideRover.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class TideRoverRule extends CardRule {
+    entersEffect = true;
+}
+export const TideRover = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: TideRoverRule
+};

package/dist/material/decks/highwave/TideRoverEffectRule.d.ts

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

package/dist/material/decks/highwave/TideRoverEffectRule.js

@@ -0,0 +1,26 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class TideRoverEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = this.endEffect();
+        const cardsPlayed = this.remind(Memory.CardsPlayed, this.nextPlayer);
+        if (cardsPlayed.length > 0) {
+            const cardIndex = cardsPlayed[cardsPlayed.length - 1];
+            const card = this.material(MaterialType.Card).getItem(cardIndex);
+            if (card.location.type === LocationType.PlayArea && cardProperties[card.id.front].type === CardType.Creature) {
+                moves.unshift(this.material(MaterialType.StunToken).createItem({
+                    location: {
+                        type: LocationType.CardStunTokens,
+                        parent: cardIndex
+                    },
+                    quantity: 2
+                }));
+            }
+        }
+        return moves;
+    }
+}

package/dist/material/decks/highwave/TropicalRuffian.js

@@ -5,7 +5,7 @@ class TropicalRuffianRule extends CardRule {
     entersEffect = true;
 }
 export const TropicalRuffian = {
-    power: 5,
+    power: 6,
     type: CardType.Creature,
     suit: CardSuit.Night,
     rule: TropicalRuffianRule

package/dist/material/decks/winsands/AbiSnakeCharmer.d.ts

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class AbiSnakeCharmerRule extends CardRule {
+    entersEffect: boolean;
+}
+export declare const AbiSnakeCharmer: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof AbiSnakeCharmerRule;
+};
+export {};

package/dist/material/decks/winsands/AbiSnakeCharmer.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class AbiSnakeCharmerRule extends CardRule {
+    entersEffect = true;
+}
+export const AbiSnakeCharmer = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: AbiSnakeCharmerRule
+};

package/dist/material/decks/winsands/AbiSnakeCharmerEffectRule.d.ts

@@ -0,0 +1,7 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class AbiSnakeCharmerEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/material/decks/winsands/AbiSnakeCharmerEffectRule.js

@@ -0,0 +1,33 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class AbiSnakeCharmerEffectRule extends EffectRule {
+    onRuleStart() {
+        const playerHelper = new PlayerHelper(this.game, this.player);
+        const foeHelper = new PlayerHelper(this.game, this.nextPlayer);
+        if (foeHelper.getPower() < playerHelper.getPower() + 7) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .moveItems((item) => ({
+            type: LocationType.PlayArea,
+            player: item.location.player === this.player ? this.nextPlayer : this.player,
+            id: cardProperties[item.id.front].type
+        }));
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/material/decks/winsands/AncientCurse.d.ts

@@ -0,0 +1,16 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class AncientCurseRule extends CardRule {
+    challenge: boolean;
+    onChallengeAccepted(): import("@gamepark/rules-api").CustomMove[];
+    onChallengeDeclined(): MaterialMove[];
+}
+export declare const AncientCurse: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof AncientCurseRule;
+};
+export {};

package/dist/material/decks/winsands/AncientCurse.js

@@ -0,0 +1,23 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class AncientCurseRule extends CardRule {
+    challenge = true;
+    onChallengeAccepted() {
+        this.addPendingEffect();
+        return super.onChallengeAccepted();
+    }
+    onChallengeDeclined() {
+        return [
+            this.customMove(CustomMoveType.Draw, { player: this.opponent, quantity: 1 }),
+            ...super.onChallengeDeclined()
+        ];
+    }
+}
+export const AncientCurse = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: AncientCurseRule
+};

package/dist/material/decks/winsands/Catadjinn.d.ts

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