@gamepark/skyrift 0.3.0 → 0.4.0

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

@@ -1,9 +1,7 @@
 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;

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

@@ -1,9 +1,7 @@
 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,

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

@@ -1,4 +1,7 @@
 import { CardRule } from '../../CardRule';
 export declare abstract class CannonCardRule extends CardRule {
     canBePlayed(): boolean;
+    canSuitBePlayed(): boolean;
+    get hasPlayedCannon(): boolean;
+    get hasBonnyTheGunner(): boolean;
 }

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

@@ -1,5 +1,6 @@
 import { Memory } from '../../../Memory';
 import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { Card } from '../../Card';
 import { cardProperties } from '../../CardProperties';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
@@ -7,15 +8,15 @@ import { CardTag } from '../../CardTag';
 import { MaterialType } from '../../MaterialType';
 export class CannonCardRule extends CardRule {
     canBePlayed() {
-        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) {
-            return false;
-        }
-        return super.canBePlayed();
+        return (!this.hasPlayedCannon || this.hasBonnyTheGunner) && super.canBePlayed();
+    }
+    canSuitBePlayed() {
+        return super.canSuitBePlayed() || (this.properties.suit === CardSuit.Night && this.hasBonnyTheGunner);
+    }
+    get hasPlayedCannon() {
+        return this.remind(Memory.CardsPlayed, this.player).some((cardIndex) => cardProperties[this.material(MaterialType.Card).getItem(cardIndex).id.front].tag === CardTag.Cannon);
+    }
+    get hasBonnyTheGunner() {
+        return new PlayerHelper(this.game, this.player).hasCard(Card.BonnyTheGunner);
     }
 }

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

@@ -1,9 +1,11 @@
+import { StunEffect } from '../../EffectTraits';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 import { CannonCardRule } from './CannonCardRule';
-declare class DarkArmageddonRule extends CannonCardRule {
-    entersEffect: boolean;
+declare class DarkArmageddonRule extends CannonCardRule implements StunEffect {
+    onEnters(): void;
+    getStunCount(): number;
 }
 export declare const DarkArmageddon: {
     power: number;

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

@@ -1,9 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 import { CannonCardRule } from './CannonCardRule';
 class DarkArmageddonRule extends CannonCardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+    getStunCount() {
+        return 3;
+    }
 }
 export const DarkArmageddon = {
     power: 2,

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

@@ -1,9 +1,11 @@
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
+import { DrawEffect } from '../../EffectTraits';
 import { CannonCardRule } from './CannonCardRule';
-declare class DawnsDoomRule extends CannonCardRule {
-    entersEffect: boolean;
+declare class DawnsDoomRule extends CannonCardRule implements DrawEffect {
+    onEnters(): void;
+    getDrawCount(): 1 | 0;
 }
 export declare const DawnsDoom: {
     power: number;

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

@@ -1,9 +1,17 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 import { CannonCardRule } from './CannonCardRule';
 class DawnsDoomRule extends CannonCardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        const onlyTwilightCards = this.playArea.id((id) => cardProperties[id.front].suit !== CardSuit.Twilight).length === 0;
+        return onlyTwilightCards ? 1 : 0;
+    }
 }
 export const DawnsDoom = {
     power: 4,

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

@@ -1,11 +1,9 @@
-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>[];
+    onFoeTurnStart(): void;
+    getEffectPlayer(): number;
 }
 export declare const EyeOfSky: {
     power: number;

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

@@ -1,15 +1,13 @@
+import { RuleId } from '../../../rules/RuleId';
 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 [];
+    onFoeTurnStart() {
+        this.addPendingEffect(RuleId.EyeOfSkyEffect);
     }
-    startEffect() {
-        return [this.startPlayerTurn(this.card, this.opponent)];
+    getEffectPlayer() {
+        return this.foe;
     }
 }
 export const EyeOfSky = {

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

@@ -1,7 +1,7 @@
-import { CustomMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { CustomMove } 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[];
+    getPlayerMoves(): import("@gamepark/rules-api").MaterialMove[];
+    onDiscard(): import("@gamepark/rules-api").MaterialMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
 }

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

@@ -1,13 +1,11 @@
 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);
+    onDiscard() {
         return [this.customMove(CustomMoveType.Draw, { player: this.player, quantity: 1 }), ...this.endEffect()];
     }
     onCustomMove(move) {

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

@@ -1,9 +1,8 @@
-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[];
+    onSkirmishWin(): void;
 }
 export declare const FortunesCourse: {
     power: number;

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

@@ -1,10 +1,10 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class FortunesCourseRule extends CardRule {
-    onWinRound() {
-        this.addPendingEffect();
-        return [];
+    onSkirmishWin() {
+        this.addPendingEffect(RuleId.GainCrystalEffect);
     }
 }
 export const FortunesCourse = {

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

@@ -3,7 +3,7 @@ import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 import { CannonCardRule } from './CannonCardRule';
 declare class GoldenApocalypseRule extends CannonCardRule {
-    challenge: boolean;
+    onEnters(): void;
 }
 export declare const GoldenApocalypse: {
     power: number;

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

@@ -1,9 +1,12 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 import { CannonCardRule } from './CannonCardRule';
 class GoldenApocalypseRule extends CannonCardRule {
-    challenge = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
 }
 export const GoldenApocalypse = {
     power: 5,

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

@@ -1,10 +1,9 @@
-import { MaterialMove } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 declare class LongJawsSilverRule extends CardRule {
-    challenge: boolean;
-    onWinRound(): MaterialMove[];
+    onEnters(): void;
+    onSkirmishWin(): void;
 }
 export declare const LongJawsSilver: {
     power: number;

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

@@ -1,14 +1,16 @@
 import { Memory } from '../../../Memory';
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class LongJawsSilverRule extends CardRule {
-    challenge = true;
-    onWinRound() {
-        if (this.remind(Memory.CurrentPlayer) !== this.player) {
-            this.addPendingEffect();
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    onSkirmishWin() {
+        if (this.remind(Memory.CurrentPlayer) === this.foe) {
+            this.addPendingEffect(RuleId.StealCrystalEffect);
         }
-        return [];
     }
 }
 export const LongJawsSilver = {

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

@@ -1,8 +1,10 @@
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class OscarScullionRule extends CardRule {
-    oncePerTurnEffect: boolean;
+import { PutPowerTokenEffect } from '../../EffectTraits';
+declare class OscarScullionRule extends CardRule implements PutPowerTokenEffect {
+    activate(): void;
+    getPutPowerTokenTargets(): import("@gamepark/rules-api").Material<number, number, number>;
 }
 export declare const OscarScullion: {
     power: number;

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

@@ -1,8 +1,14 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class OscarScullionRule extends CardRule {
-    oncePerTurnEffect = true;
+    activate() {
+        this.addPendingEffect(RuleId.PutPowerTokensEffect);
+    }
+    getPutPowerTokenTargets() {
+        return this.creatures;
+    }
 }
 export const OscarScullion = {
     power: 2,

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

@@ -1,8 +1,10 @@
 import { CardRule } from '../../CardRule';
+import { DrawEffect } from '../../EffectTraits';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class OttoFactotumRule extends CardRule {
-    entersEffect: boolean;
+declare class OttoFactotumRule extends CardRule implements DrawEffect {
+    onEnters(): void;
+    getDrawCount(): number;
 }
 export declare const OttoFactotum: {
     power: number;

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

@@ -1,8 +1,17 @@
+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 OttoFactotumRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        const cardsInHands = this.material(MaterialType.Card).location(LocationType.PlayerHand);
+        return cardsInHands.player(this.foe).length - cardsInHands.player(this.player).length;
+    }
 }
 export const OttoFactotum = {
     power: 2,

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

@@ -1,8 +1,11 @@
+import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class RiggingRaidersRule extends CardRule {
-    oncePerTurnEffect: boolean;
+import { DestroyEffect } from '../../EffectTraits';
+declare class RiggingRaidersRule extends CardRule implements DestroyEffect {
+    activate(): void;
+    getDestroyTargets(): Material;
 }
 export declare const RiggingRaiders: {
     power: number;

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

@@ -1,8 +1,16 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
+import { createCardRule } from '../../createCardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class RiggingRaidersRule extends CardRule {
-    oncePerTurnEffect = true;
+    activate() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        const myPower = this.getPower();
+        return this.creatures.player(this.foe).index((index) => createCardRule(this.game, index).getPower() < myPower);
+    }
 }
 export const RiggingRaiders = {
     power: 2,

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

@@ -1,11 +1,14 @@
-import { MaterialMove } from '@gamepark/rules-api';
+import { Material } from '@gamepark/rules-api';
 import { Deck } from '../../../Deck';
 import { Card } from '../../Card';
 import { CardRule } from '../../CardRule';
+import { ReturnCardEffect } from '../../EffectTraits';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class SeaScorcherRule extends CardRule {
-    onCardEnters(card: Card, side: Deck): MaterialMove[];
+declare class SeaScorcherRule extends CardRule implements ReturnCardEffect {
+    onCardEnters(card: Card, side: Deck): void;
+    getReturnTargets(): Material;
+    isReturnOptional(): boolean;
 }
 export declare const SeaScorcher: {
     power: number;

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

@@ -1,14 +1,25 @@
+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';
 class SeaScorcherRule extends CardRule {
     onCardEnters(card, side) {
         if (side === this.player && cardProperties[card].tag === CardTag.Cannon) {
-            this.addPendingEffect();
+            this.addPendingEffect(RuleId.ReturnCardEffect);
         }
-        return [];
+    }
+    getReturnTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerDiscard)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].tag === CardTag.Cannon);
+    }
+    isReturnOptional() {
+        return true;
     }
 }
 export const SeaScorcher = {

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

@@ -1,8 +1,10 @@
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class SurpriseLootRule extends CardRule {
-    entersEffect: boolean;
+import { StashPowerTokenEffect } from '../../EffectTraits';
+declare class SurpriseLootRule extends CardRule implements StashPowerTokenEffect {
+    onEnters(): void;
+    getStashPowerTokenCount(): number;
 }
 export declare const SurpriseLoot: {
     power: number;

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

@@ -1,8 +1,14 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class SurpriseLootRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.StashPowerTokensEffect);
+    }
+    getStashPowerTokenCount() {
+        return this.creatures.player(this.player).length;
+    }
 }
 export const SurpriseLoot = {
     power: 2,

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

@@ -1,8 +1,12 @@
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class TideRoverRule extends CardRule {
-    entersEffect: boolean;
+import { StunEffect } from '../../EffectTraits';
+declare class TideRoverRule extends CardRule implements StunEffect {
+    onEnters(): void;
+    getStunTargets(): import("@gamepark/rules-api").Material<number, number, number>;
+    getStunCount(): number;
+    isAutoStun(): boolean;
 }
 export declare const TideRover: {
     power: number;

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

@@ -1,8 +1,22 @@
+import { Memory } from '../../../Memory';
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class TideRoverRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+    getStunTargets() {
+        const opponentCardsPlayed = this.remind(Memory.CardsPlayed, this.foe);
+        return this.creatures.index(opponentCardsPlayed[opponentCardsPlayed.length - 1]);
+    }
+    getStunCount() {
+        return 2;
+    }
+    isAutoStun() {
+        return true;
+    }
 }
 export const TideRover = {
     power: 2,

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

@@ -2,7 +2,7 @@ import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 declare class TropicalRuffianRule extends CardRule {
-    entersEffect: boolean;
+    onEnters(): void;
 }
 export declare const TropicalRuffian: {
     power: number;

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

@@ -1,8 +1,11 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class TropicalRuffianRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.DiscardEffect);
+    }
 }
 export const TropicalRuffian = {
     power: 6,

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+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 || !this.creatures.length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.creatures.moveItems((item) => ({
+            type: LocationType.PlayArea,
+            player: item.location.player === this.player ? this.nextPlayer : this.player,
+            id: cardProperties[item.id.front].type
+        }));
+    }
+    get creatures() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

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

@@ -0,0 +1,17 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { ChallengeEffect, DrawEffect } from '../../EffectTraits';
+declare class AncientCurseRule extends CardRule implements DrawEffect, ChallengeEffect {
+    onEnters(): void;
+    getDrawPlayer(): number;
+    onChallengeAccepted(): void;
+    onChallengeDeclined(): void;
+}
+export declare const AncientCurse: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof AncientCurseRule;
+};
+export {};