@gamepark/skyrift 0.2.9 → 0.3.0

package/dist/Deck.d.ts

@@ -1,4 +1,5 @@
 export declare enum Deck {
     HearthBlade = 1,
+    WinSands = 2,
     HighWave = 6
 }

package/dist/Deck.js

@@ -1,5 +1,6 @@
 export var Deck;
 (function (Deck) {
     Deck[Deck["HearthBlade"] = 1] = "HearthBlade";
+    Deck[Deck["WinSands"] = 2] = "WinSands";
     Deck[Deck["HighWave"] = 6] = "HighWave";
 })(Deck || (Deck = {}));

package/dist/Memory.d.ts

@@ -7,5 +7,6 @@ export declare enum Memory {
     CurrentPlayer = 6,
     NextRoundStartPlayer = 7,
     EffectCount = 8,
-    ChallengeConceded = 9
+    ChallengeConceded = 9,
+    OngoingEffects = 10
 }

package/dist/Memory.js

@@ -9,4 +9,5 @@ export var Memory;
     Memory[Memory["NextRoundStartPlayer"] = 7] = "NextRoundStartPlayer";
     Memory[Memory["EffectCount"] = 8] = "EffectCount";
     Memory[Memory["ChallengeConceded"] = 9] = "ChallengeConceded";
+    Memory[Memory["OngoingEffects"] = 10] = "OngoingEffects";
 })(Memory || (Memory = {}));

package/dist/SkyriftRules.d.ts

@@ -20,6 +20,15 @@ import { TideRoverEffectRule } from './material/decks/highwave/TideRoverEffectRu
 import { RiggingRaidersEffectRule } from './material/decks/highwave/RiggingRaidersEffectRule';
 import { OscarScullionEffectRule } from './material/decks/highwave/OscarScullionEffectRule';
 import { SurpriseLootEffectRule } from './material/decks/highwave/SurpriseLootEffectRule';
+import { AbiSnakeCharmerEffectRule } from './material/decks/winsands/AbiSnakeCharmerEffectRule';
+import { DeathTrapEffectRule } from './material/decks/winsands/DeathTrapEffectRule';
+import { DesertRaiderEffectRule } from './material/decks/winsands/DesertRaiderEffectRule';
+import { OasisShamanEffectRule } from './material/decks/winsands/OasisShamanEffectRule';
+import { SandWalkersEffectRule } from './material/decks/winsands/SandWalkersEffectRule';
+import { StarlightBazaarEffectRule } from './material/decks/winsands/StarlightBazaarEffectRule';
+import { VandalsEffectRule } from './material/decks/winsands/VandalsEffectRule';
+import { WindWrathEffectRule } from './material/decks/winsands/WindWrathEffectRule';
+import { WishLampEffectRule } from './material/decks/winsands/WishLampEffectRule';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
 import { ChallengeRule } from './rules/ChallengeRule';
@@ -55,6 +64,18 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
         114: typeof WatchTowerEffectRule;
         115: typeof DrawEffectRule;
         116: typeof HarvestEffectRule;
+        201: typeof DesertRaiderEffectRule;
+        202: typeof DrawEffectRule;
+        204: typeof AbiSnakeCharmerEffectRule;
+        206: typeof VandalsEffectRule;
+        207: typeof DrawEffectRule;
+        208: typeof OasisShamanEffectRule;
+        211: typeof SandWalkersEffectRule;
+        212: typeof WishLampEffectRule;
+        213: typeof StarlightBazaarEffectRule;
+        214: typeof DrawEffectRule;
+        215: typeof WindWrathEffectRule;
+        216: typeof DeathTrapEffectRule;
         601: typeof SeaScorcherEffectRule;
         602: typeof DrawEffectRule;
         603: typeof EyeOfSkyEffectRule;

package/dist/SkyriftRules.js

@@ -20,6 +20,15 @@ import { TideRoverEffectRule } from './material/decks/highwave/TideRoverEffectRu
 import { RiggingRaidersEffectRule } from './material/decks/highwave/RiggingRaidersEffectRule';
 import { OscarScullionEffectRule } from './material/decks/highwave/OscarScullionEffectRule';
 import { SurpriseLootEffectRule } from './material/decks/highwave/SurpriseLootEffectRule';
+import { AbiSnakeCharmerEffectRule } from './material/decks/winsands/AbiSnakeCharmerEffectRule';
+import { DeathTrapEffectRule } from './material/decks/winsands/DeathTrapEffectRule';
+import { DesertRaiderEffectRule } from './material/decks/winsands/DesertRaiderEffectRule';
+import { OasisShamanEffectRule } from './material/decks/winsands/OasisShamanEffectRule';
+import { SandWalkersEffectRule } from './material/decks/winsands/SandWalkersEffectRule';
+import { StarlightBazaarEffectRule } from './material/decks/winsands/StarlightBazaarEffectRule';
+import { VandalsEffectRule } from './material/decks/winsands/VandalsEffectRule';
+import { WindWrathEffectRule } from './material/decks/winsands/WindWrathEffectRule';
+import { WishLampEffectRule } from './material/decks/winsands/WishLampEffectRule';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
 import { Memory } from './Memory';
@@ -58,6 +67,18 @@ export class SkyriftRules extends SecretMaterialRules {
         [RuleId.WatchTowerEffect]: WatchTowerEffectRule,
         [RuleId.ConfluenceEffect]: DrawEffectRule,
         [RuleId.HarvestEffect]: HarvestEffectRule,
+        [RuleId.DesertRaiderEffect]: DesertRaiderEffectRule,
+        [RuleId.MetamorphEffect]: DrawEffectRule,
+        [RuleId.AbiSnakeCharmerEffect]: AbiSnakeCharmerEffectRule,
+        [RuleId.VandalsEffect]: VandalsEffectRule,
+        [RuleId.MushaFakirEffect]: DrawEffectRule,
+        [RuleId.OasisShamanEffect]: OasisShamanEffectRule,
+        [RuleId.SandWalkersEffect]: SandWalkersEffectRule,
+        [RuleId.WishLampEffect]: WishLampEffectRule,
+        [RuleId.StarlightBazaarEffect]: StarlightBazaarEffectRule,
+        [RuleId.AncientCurseEffect]: DrawEffectRule,
+        [RuleId.WindWrathEffect]: WindWrathEffectRule,
+        [RuleId.DeathTrapEffect]: DeathTrapEffectRule,
         [RuleId.SeaScorcherEffect]: SeaScorcherEffectRule,
         [RuleId.AeliaSteadyHandEffect]: DrawEffectRule,
         [RuleId.EyeOfSkyEffect]: EyeOfSkyEffectRule,
@@ -100,16 +121,22 @@ export class SkyriftRules extends SecretMaterialRules {
             if (origin.type === LocationType.PlayArea && move.location.type !== LocationType.PlayArea) {
                 const cardRule = new PlayerHelper(this.game).getCardRule(move.itemIndex);
                 moves.push(...cardRule.onLeave());
+                this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => e.cardIndex !== move.itemIndex));
             }
         }
         else if (isMoveItemTypeAtOnce(MaterialType.Card)(move)) {
+            const leavingIndexes = [];
             for (const itemIndex of move.indexes) {
                 const origin = this.material(MaterialType.Card).getItem(itemIndex).location;
                 if (origin.type === LocationType.PlayArea && move.location.type !== LocationType.PlayArea) {
                     const cardRule = new PlayerHelper(this.game).getCardRule(itemIndex);
                     moves.push(...cardRule.onLeave());
+                    leavingIndexes.push(itemIndex);
                 }
             }
+            if (leavingIndexes.length > 0) {
+                this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => !leavingIndexes.includes(e.cardIndex)));
+            }
         }
         return moves;
     }

package/dist/SkyriftSetup.js

@@ -3,6 +3,7 @@ import { shuffle } from 'es-toolkit';
 import { Deck } from './Deck';
 import { HearthBlade } from './material/decks/HearthBlade';
 import { HighWave } from './material/decks/HighWave';
+import { WinSands } from './material/decks/WinSands';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
 import { Memory } from './Memory';
@@ -10,6 +11,7 @@ import { RuleId } from './rules/RuleId';
 import { SkyriftRules } from './SkyriftRules';
 const deckConfigurations = {
     [Deck.HearthBlade]: HearthBlade,
+    [Deck.WinSands]: WinSands,
     [Deck.HighWave]: HighWave
 };
 export class SkyriftSetup extends MaterialGameSetup {
@@ -17,6 +19,7 @@ export class SkyriftSetup extends MaterialGameSetup {
     setupMaterial(_options) {
         this.setupDecks();
         this.memorize(Memory.PendingEffects, []);
+        this.memorize(Memory.OngoingEffects, []);
         this.memorize(Memory.CrystalsToWin, 6);
     }
     setupDecks() {

package/dist/material/Card.d.ts

@@ -16,6 +16,22 @@ export declare enum Card {
     WatchTower = 114,
     Confluence = 115,
     Harvest = 116,
+    DesertRaider = 201,
+    Metamorph = 202,
+    ErgDeathslayer = 203,
+    AbiSnakeCharmer = 204,
+    Catadjinn = 205,
+    Vandals = 206,
+    MushaFakir = 207,
+    OasisShaman = 208,
+    MalikShadowtracker = 209,
+    DuneWardrums = 210,
+    SandWalkers = 211,
+    WishLamp = 212,
+    StarlightBazaar = 213,
+    AncientCurse = 214,
+    WindWrath = 215,
+    DeathTrap = 216,
     SeaScorcher = 601,
     AeliaSteadyHand = 602,
     EyeOfSky = 603,

package/dist/material/Card.js

@@ -16,6 +16,22 @@ export var Card;
     Card[Card["WatchTower"] = 114] = "WatchTower";
     Card[Card["Confluence"] = 115] = "Confluence";
     Card[Card["Harvest"] = 116] = "Harvest";
+    Card[Card["DesertRaider"] = 201] = "DesertRaider";
+    Card[Card["Metamorph"] = 202] = "Metamorph";
+    Card[Card["ErgDeathslayer"] = 203] = "ErgDeathslayer";
+    Card[Card["AbiSnakeCharmer"] = 204] = "AbiSnakeCharmer";
+    Card[Card["Catadjinn"] = 205] = "Catadjinn";
+    Card[Card["Vandals"] = 206] = "Vandals";
+    Card[Card["MushaFakir"] = 207] = "MushaFakir";
+    Card[Card["OasisShaman"] = 208] = "OasisShaman";
+    Card[Card["MalikShadowtracker"] = 209] = "MalikShadowtracker";
+    Card[Card["DuneWardrums"] = 210] = "DuneWardrums";
+    Card[Card["SandWalkers"] = 211] = "SandWalkers";
+    Card[Card["WishLamp"] = 212] = "WishLamp";
+    Card[Card["StarlightBazaar"] = 213] = "StarlightBazaar";
+    Card[Card["AncientCurse"] = 214] = "AncientCurse";
+    Card[Card["WindWrath"] = 215] = "WindWrath";
+    Card[Card["DeathTrap"] = 216] = "DeathTrap";
     Card[Card["SeaScorcher"] = 601] = "SeaScorcher";
     Card[Card["AeliaSteadyHand"] = 602] = "AeliaSteadyHand";
     Card[Card["EyeOfSky"] = 603] = "EyeOfSky";

package/dist/material/CardProperties.js

@@ -15,6 +15,22 @@ import { OscarScullion } from './decks/highwave/OscarScullion';
 import { SurpriseLoot } from './decks/highwave/SurpriseLoot';
 import { FortunesCourse } from './decks/highwave/FortunesCourse';
 import { TropicalRuffian } from './decks/highwave/TropicalRuffian';
+import { AbiSnakeCharmer } from './decks/winsands/AbiSnakeCharmer';
+import { AncientCurse } from './decks/winsands/AncientCurse';
+import { Catadjinn } from './decks/winsands/Catadjinn';
+import { DeathTrap } from './decks/winsands/DeathTrap';
+import { DesertRaider } from './decks/winsands/DesertRaider';
+import { DuneWardrums } from './decks/winsands/DuneWardrums';
+import { ErgDeathslayer } from './decks/winsands/ErgDeathslayer';
+import { MalikShadowtracker } from './decks/winsands/MalikShadowtracker';
+import { Metamorph } from './decks/winsands/Metamorph';
+import { MushaFakir } from './decks/winsands/MushaFakir';
+import { OasisShaman } from './decks/winsands/OasisShaman';
+import { SandWalkers } from './decks/winsands/SandWalkers';
+import { StarlightBazaar } from './decks/winsands/StarlightBazaar';
+import { Vandals } from './decks/winsands/Vandals';
+import { WindWrath } from './decks/winsands/WindWrath';
+import { WishLamp } from './decks/winsands/WishLamp';
 import { Armada } from './decks/heathblade/Armada';
 import { Confluence } from './decks/heathblade/Confluence';
 import { CoverOfNight } from './decks/heathblade/CoverOfNight';
@@ -48,6 +64,22 @@ export const cardProperties = {
     [Card.WatchTower]: WatchTower,
     [Card.Confluence]: Confluence,
     [Card.Harvest]: Harvest,
+    [Card.DesertRaider]: DesertRaider,
+    [Card.Metamorph]: Metamorph,
+    [Card.ErgDeathslayer]: ErgDeathslayer,
+    [Card.AbiSnakeCharmer]: AbiSnakeCharmer,
+    [Card.Catadjinn]: Catadjinn,
+    [Card.Vandals]: Vandals,
+    [Card.MushaFakir]: MushaFakir,
+    [Card.OasisShaman]: OasisShaman,
+    [Card.MalikShadowtracker]: MalikShadowtracker,
+    [Card.DuneWardrums]: DuneWardrums,
+    [Card.SandWalkers]: SandWalkers,
+    [Card.WishLamp]: WishLamp,
+    [Card.StarlightBazaar]: StarlightBazaar,
+    [Card.AncientCurse]: AncientCurse,
+    [Card.WindWrath]: WindWrath,
+    [Card.DeathTrap]: DeathTrap,
     [Card.SeaScorcher]: SeaScorcher,
     [Card.AeliaSteadyHand]: AeliaSteadyHand,
     [Card.EyeOfSky]: EyeOfSky,

package/dist/material/CardRule.d.ts

@@ -1,8 +1,8 @@
 import { MaterialGame, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
 import { Deck } from '../Deck';
-import { RuleId } from '../rules/RuleId';
 import { Card, CardId } from './Card';
 import { CardTag } from './CardTag';
+import { OngoingEffectType } from './OngoingEffect';
 export declare class CardRule extends MaterialRulesPart {
     index: number;
     constructor(game: MaterialGame, index: number);
@@ -16,7 +16,7 @@ export declare class CardRule extends MaterialRulesPart {
     entersEffect: boolean;
     challenge: boolean;
     onChallengeAccepted(): import("@gamepark/rules-api").CustomMove[];
-    onChallengeDeclined(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.EndRound>[];
+    onChallengeDeclined(): MaterialMove[];
     onLeave(): MaterialMove[];
     removePowerTokens(): import("@gamepark/rules-api").DeleteItem<number>[];
     removeStunTokens(): import("@gamepark/rules-api").DeleteItem<number>[];
@@ -27,6 +27,7 @@ export declare class CardRule extends MaterialRulesPart {
     getPower(): number;
     getPowerIfNotStunned(): number;
     addPendingEffect(): void;
+    addOngoingEffect(type: OngoingEffectType): void;
     get player(): number;
     get opponent(): number;
     startEffect(): MaterialMove[];

package/dist/material/CardRule.js

@@ -6,6 +6,7 @@ import { cardProperties } from './CardProperties';
 import { CardSuit } from './CardSuit';
 import { LocationType } from './LocationType';
 import { MaterialType } from './MaterialType';
+import { OngoingEffectType } from './OngoingEffect';
 export class CardRule extends MaterialRulesPart {
     index;
     constructor(game, index) {
@@ -83,6 +84,9 @@ export class CardRule extends MaterialRulesPart {
     addPendingEffect() {
         this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index }]);
     }
+    addOngoingEffect(type) {
+        this.memorize(Memory.OngoingEffects, (effects) => [...effects, { type, cardIndex: this.index }]);
+    }
     get player() {
         return this.item.location.player;
     }
@@ -103,6 +107,16 @@ export class CardRule extends MaterialRulesPart {
         }
     }
     canBePlayed() {
+        const ongoingEffects = this.remind(Memory.OngoingEffects);
+        const forcedSuit = ongoingEffects.find((e) => e.type === OngoingEffectType.ForcedSuit);
+        if (forcedSuit) {
+            const sourceCard = this.material(MaterialType.Card).getItem(forcedSuit.cardIndex);
+            if (sourceCard.location.player !== this.player) {
+                const forcedSuitValue = cardProperties[sourceCard.id.front].suit;
+                if (this.properties.suit !== forcedSuitValue)
+                    return false;
+            }
+        }
         const currentSuit = this.remind(Memory.Suit);
         const cardSuit = this.properties.suit;
         return !(cardSuit === CardSuit.Night && currentSuit === CardSuit.Day) && !(cardSuit === CardSuit.Day && currentSuit === CardSuit.Night);

package/dist/material/OngoingEffect.d.ts

@@ -0,0 +1,8 @@
+export declare enum OngoingEffectType {
+    ForcedSuit = 1,
+    DeathTrap = 2
+}
+export type OngoingEffect = {
+    type: OngoingEffectType;
+    cardIndex: number;
+};

package/dist/material/OngoingEffect.js

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

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

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

package/dist/material/decks/WinSands.js

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

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

@@ -1,17 +1,15 @@
 import { EffectRule } from '../../../rules/EffectRule';
-import { Memory } from '../../../Memory';
 import { LocationType } from '../../LocationType';
 import { MaterialType } from '../../MaterialType';
 export class OzmaTheMageEffectRule extends EffectRule {
     onRuleStart() {
-        const ozmaIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
         return [
             this.material(MaterialType.PowerToken)
                 .location(LocationType.PowerTokenStock)
                 .createItem({
                 location: {
                     type: LocationType.CardPowerTokens,
-                    parent: ozmaIndex
+                    parent: this.effectCardIndex
                 }
             }),
             ...this.endEffect()

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

@@ -1,4 +1,3 @@
-import { Memory } from '../../../Memory';
 import { cardProperties } from '../../CardProperties';
 import { CardType } from '../../CardType';
 import { LocationType } from '../../LocationType';
@@ -7,13 +6,12 @@ import { EffectRule } from '../../../rules/EffectRule';
 export class RobbinsMasterOfArmsEffectRule extends EffectRule {
     onRuleStart() {
         const moves = [];
-        const robbinsIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
         const otherCreatures = this.material(MaterialType.Card)
             .location(LocationType.PlayArea)
             .player(this.player)
             .id((id) => cardProperties[id.front].type === CardType.Creature)
             .getIndexes()
-            .filter(index => index !== robbinsIndex);
+            .filter(index => index !== this.effectCardIndex);
         for (const creatureIndex of otherCreatures) {
             moves.push(this.material(MaterialType.PowerToken)
                 .location(LocationType.PowerTokenStock)

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

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

@@ -0,0 +1,24 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class CatadjinnRule extends CardRule {
+    challenge = true;
+    getPowerIfNotStunned() {
+        const nonNightCards = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => {
+            const suit = cardProperties[id.front].suit;
+            return suit === CardSuit.Twilight || suit === CardSuit.Day;
+        });
+        return Math.max(0, super.getPowerIfNotStunned() - nonNightCards.length);
+    }
+}
+export const Catadjinn = {
+    power: 6,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: CatadjinnRule
+};

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

@@ -0,0 +1,4 @@
+import { CardRule } from '../../CardRule';
+export declare class CreatureBonusCardRule extends CardRule {
+    getPowerIfNotStunned(): number;
+}

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

@@ -0,0 +1,14 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class CreatureBonusCardRule extends CardRule {
+    getPowerIfNotStunned() {
+        const myCreatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        return super.getPowerIfNotStunned() + myCreatures.length - 1;
+    }
+}

package/dist/material/decks/winsands/DeathTrap.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 DeathTrapRule extends CardRule {
+    onEnters(): MaterialMove[];
+}
+export declare const DeathTrap: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DeathTrapRule;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class DeathTrapRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.DeathTrap);
+        return [];
+    }
+}
+export const DeathTrap = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: DeathTrapRule
+};

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

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

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

@@ -0,0 +1,18 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class DeathTrapEffectRule extends EffectRule {
+    onRuleStart() {
+        const currentPlayer = this.remind(Memory.CurrentPlayer);
+        const cardsPlayed = this.remind(Memory.CardsPlayed, currentPlayer);
+        const targetIndex = cardsPlayed[cardsPlayed.length - 1];
+        return [
+            this.material(MaterialType.Card).index(targetIndex).moveItem({
+                type: LocationType.PlayerDiscard,
+                player: currentPlayer
+            }),
+            ...this.endEffect()
+        ];
+    }
+}

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

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