@gamepark/skyrift 0.2.9 → 0.4.0

package/dist/Deck.d.ts

@@ -1,4 +1,6 @@
 export declare enum Deck {
     HearthBlade = 1,
+    WindSands = 2,
+    GraveHurt = 3,
     HighWave = 6
 }

package/dist/Deck.js

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

package/dist/Memory.d.ts

@@ -3,9 +3,10 @@ export declare enum Memory {
     CardsPlayed = 2,
     Suit = 3,
     PendingEffects = 4,
-    OncePerTurnEffects = 5,
+    ActivatedCards = 5,
     CurrentPlayer = 6,
     NextRoundStartPlayer = 7,
     EffectCount = 8,
-    ChallengeConceded = 9
+    ChallengeConceded = 9,
+    OngoingEffects = 10
 }

package/dist/Memory.js

@@ -4,9 +4,10 @@ export var Memory;
     Memory[Memory["CardsPlayed"] = 2] = "CardsPlayed";
     Memory[Memory["Suit"] = 3] = "Suit";
     Memory[Memory["PendingEffects"] = 4] = "PendingEffects";
-    Memory[Memory["OncePerTurnEffects"] = 5] = "OncePerTurnEffects";
+    Memory[Memory["ActivatedCards"] = 5] = "ActivatedCards";
     Memory[Memory["CurrentPlayer"] = 6] = "CurrentPlayer";
     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

@@ -1,39 +1,33 @@
 import { CustomMove, ItemMove, MaterialGame, MaterialMove, MaterialMoveRandomized, MaterialMoveView, PlayMoveContext, PositiveSequenceStrategy, SecretMaterialRules, TimeLimit } from '@gamepark/rules-api';
 import { Deck } from './Deck';
+import { CavernSkulkerEffectRule } from './material/decks/gravehurt/CavernSkulkerEffectRule';
+import { DoomEffectRule } from './material/decks/gravehurt/DoomEffectRule';
 import { ArmadaEffectRule } from './material/decks/heathblade/ArmadaEffectRule';
-import { CoverOfNightEffectRule } from './material/decks/heathblade/CoverOfNightEffectRule';
-import { HarvestEffectRule } from './material/decks/heathblade/HarvestEffectRule';
-import { LoyalSquireEffectRule } from './material/decks/heathblade/LoyalSquireEffectRule';
-import { OzmaTheMageEffectRule } from './material/decks/heathblade/OzmaTheMageEffectRule';
 import { PrincessLithaEffectRule } from './material/decks/heathblade/PrincessLithaEffectRule';
-import { RobbinsMasterOfArmsEffectRule } from './material/decks/heathblade/RobbinsMasterOfArmsEffectRule';
-import { SacrificeEffectRule } from './material/decks/heathblade/SacrificeEffectRule';
-import { SoulBladeEffectRule } from './material/decks/heathblade/SoulBladeEffectRule';
-import { WatchTowerEffectRule } from './material/decks/heathblade/WatchTowerEffectRule';
 import { BoardingPartyEffectRule } from './material/decks/highwave/BoardingPartyEffectRule';
-import { DarkArmageddonEffectRule } from './material/decks/highwave/DarkArmageddonEffectRule';
-import { DawnsDoomEffectRule } from './material/decks/highwave/DawnsDoomEffectRule';
-import { OttoFactotumEffectRule } from './material/decks/highwave/OttoFactotumEffectRule';
-import { SeaScorcherEffectRule } from './material/decks/highwave/SeaScorcherEffectRule';
 import { EyeOfSkyEffectRule } from './material/decks/highwave/EyeOfSkyEffectRule';
-import { TideRoverEffectRule } from './material/decks/highwave/TideRoverEffectRule';
-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/windsands/AbiSnakeCharmerEffectRule';
+import { WindWrathEffectRule } from './material/decks/windsands/WindWrathEffectRule';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
-import { ChallengeRule } from './rules/ChallengeRule';
+import { ChallengeEffectRule } from './rules/ChallengeEffectRule';
+import { ChallengeResponseRule } from './rules/ChallengeResponseRule';
+import { DestroyEffectRule } from './rules/DestroyEffectRule';
 import { DiscardEffectRule } from './rules/DiscardEffectRule';
 import { DrawEffectRule } from './rules/DrawEffectRule';
 import { EndPlayerTurnRule } from './rules/EndPlayerTurnRule';
 import { EndRoundRule } from './rules/EndRoundRule';
 import { GainCrystalEffectRule } from './rules/GainCrystalEffectRule';
-import { MayChallengeRule } from './rules/MayChallengeRule';
+import { PlayCardEffectRule } from './rules/PlayCardEffectRule';
 import { PlayCardRule } from './rules/PlayCardRule';
 import { PrepareNextRoundRule } from './rules/PrepareNextRoundRule';
+import { PutPowerTokenEffectRule } from './rules/PutPowerTokenEffectRule';
+import { ReturnCardEffectRule } from './rules/ReturnCardEffectRule';
 import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
 import { StartRoundRule } from './rules/StartRoundRule';
+import { StashPowerTokensEffectRule } from './rules/StashPowerTokensEffectRule';
 import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
+import { StunCardRule } from './rules/StunCardRule';
 export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType, LocationType> implements TimeLimit<MaterialGame<Deck, MaterialType, LocationType>, MaterialMove<Deck, MaterialType, LocationType>, Deck> {
     rules: {
         1: typeof StartRoundRule;
@@ -42,33 +36,26 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
         4: typeof EndPlayerTurnRule;
         5: typeof EndRoundRule;
         6: typeof PrepareNextRoundRule;
-        7: typeof MayChallengeRule;
-        8: typeof ChallengeRule;
-        102: typeof LoyalSquireEffectRule;
-        103: typeof PrincessLithaEffectRule;
-        104: typeof RobbinsMasterOfArmsEffectRule;
-        109: typeof OzmaTheMageEffectRule;
+        20: typeof ChallengeEffectRule;
+        21: typeof ChallengeResponseRule;
+        22: typeof DrawEffectRule;
+        23: typeof DiscardEffectRule;
+        24: typeof DestroyEffectRule;
+        25: typeof StunCardRule;
+        26: typeof ReturnCardEffectRule;
+        27: typeof PutPowerTokenEffectRule;
+        28: typeof StashPowerTokensEffectRule;
+        29: typeof GainCrystalEffectRule;
+        30: typeof StealCrystalEffectRule;
+        204: typeof AbiSnakeCharmerEffectRule;
+        31: typeof PlayCardEffectRule;
         110: typeof ArmadaEffectRule;
-        111: typeof SoulBladeEffectRule;
-        112: typeof CoverOfNightEffectRule;
-        113: typeof SacrificeEffectRule;
-        114: typeof WatchTowerEffectRule;
-        115: typeof DrawEffectRule;
-        116: typeof HarvestEffectRule;
-        601: typeof SeaScorcherEffectRule;
-        602: typeof DrawEffectRule;
+        103: typeof PrincessLithaEffectRule;
+        215: typeof WindWrathEffectRule;
+        302: typeof CavernSkulkerEffectRule;
+        315: typeof DoomEffectRule;
         603: typeof EyeOfSkyEffectRule;
-        605: typeof DiscardEffectRule;
-        606: typeof RiggingRaidersEffectRule;
-        607: typeof OttoFactotumEffectRule;
-        608: typeof OscarScullionEffectRule;
-        609: typeof TideRoverEffectRule;
-        610: typeof StealCrystalEffectRule;
-        612: typeof GainCrystalEffectRule;
-        613: typeof DarkArmageddonEffectRule;
         614: typeof BoardingPartyEffectRule;
-        615: typeof DawnsDoomEffectRule;
-        616: typeof SurpriseLootEffectRule;
     };
     locationsStrategies: {
         1: {
@@ -76,17 +63,20 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
             2: PositiveSequenceStrategy<number, number, number>;
             7: PositiveSequenceStrategy<number, number, number>;
             8: PositiveSequenceStrategy<number, number, number>;
+            14: PositiveSequenceStrategy<number, number, number>;
         };
     };
     hidingStrategies: {
         1: {
             1: import("@gamepark/rules-api").HidingStrategy<number, number>;
-            2: import("@gamepark/rules-api").HidingStrategy;
+            2: import("@gamepark/rules-api").HidingStrategy<number, number>;
+            14: import("@gamepark/rules-api").HidingStrategy<number, number>;
         };
     };
     play(move: MaterialMoveRandomized<Deck, MaterialType, LocationType> | MaterialMoveView<Deck, MaterialType, LocationType>, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number>[];
     protected beforeItemMove(move: ItemMove): MaterialMove<Deck, MaterialType, LocationType, number>[];
     protected afterItemMove(move: ItemMove, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number>[];
     protected onCustomMove(move: CustomMove, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number>[];
+    isUnpredictableMove(move: MaterialMove<Deck, MaterialType, LocationType>, player: Deck): boolean;
     giveTime(): number;
 }

package/dist/SkyriftRules.js

@@ -1,42 +1,36 @@
-import { hideFront, hideFrontToOthers, isMoveItemType, isMoveItemTypeAtOnce, MoveKind, PositiveSequenceStrategy, SecretMaterialRules } from '@gamepark/rules-api';
+import { hideFront, hideFrontToOthers, isMoveItemType, isMoveItemTypeAtOnce, isStartPlayerTurn, MoveKind, PositiveSequenceStrategy, SecretMaterialRules } from '@gamepark/rules-api';
 import { CustomMoveType } from './CustomMoveType';
+import { createCardRule } from './material/createCardRule';
+import { CavernSkulkerEffectRule } from './material/decks/gravehurt/CavernSkulkerEffectRule';
+import { DoomEffectRule } from './material/decks/gravehurt/DoomEffectRule';
 import { ArmadaEffectRule } from './material/decks/heathblade/ArmadaEffectRule';
-import { CoverOfNightEffectRule } from './material/decks/heathblade/CoverOfNightEffectRule';
-import { HarvestEffectRule } from './material/decks/heathblade/HarvestEffectRule';
-import { LoyalSquireEffectRule } from './material/decks/heathblade/LoyalSquireEffectRule';
-import { OzmaTheMageEffectRule } from './material/decks/heathblade/OzmaTheMageEffectRule';
 import { PrincessLithaEffectRule } from './material/decks/heathblade/PrincessLithaEffectRule';
-import { RobbinsMasterOfArmsEffectRule } from './material/decks/heathblade/RobbinsMasterOfArmsEffectRule';
-import { SacrificeEffectRule } from './material/decks/heathblade/SacrificeEffectRule';
-import { SoulBladeEffectRule } from './material/decks/heathblade/SoulBladeEffectRule';
-import { WatchTowerEffectRule } from './material/decks/heathblade/WatchTowerEffectRule';
 import { BoardingPartyEffectRule } from './material/decks/highwave/BoardingPartyEffectRule';
-import { DarkArmageddonEffectRule } from './material/decks/highwave/DarkArmageddonEffectRule';
-import { DawnsDoomEffectRule } from './material/decks/highwave/DawnsDoomEffectRule';
-import { OttoFactotumEffectRule } from './material/decks/highwave/OttoFactotumEffectRule';
-import { SeaScorcherEffectRule } from './material/decks/highwave/SeaScorcherEffectRule';
 import { EyeOfSkyEffectRule } from './material/decks/highwave/EyeOfSkyEffectRule';
-import { TideRoverEffectRule } from './material/decks/highwave/TideRoverEffectRule';
-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/windsands/AbiSnakeCharmerEffectRule';
+import { WindWrathEffectRule } from './material/decks/windsands/WindWrathEffectRule';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
 import { Memory } from './Memory';
-import { ChallengeRule } from './rules/ChallengeRule';
+import { ChallengeEffectRule } from './rules/ChallengeEffectRule';
+import { ChallengeResponseRule } from './rules/ChallengeResponseRule';
+import { DestroyEffectRule } from './rules/DestroyEffectRule';
 import { DiscardEffectRule } from './rules/DiscardEffectRule';
 import { DrawEffectRule } from './rules/DrawEffectRule';
 import { EndPlayerTurnRule } from './rules/EndPlayerTurnRule';
 import { EndRoundRule } from './rules/EndRoundRule';
 import { GainCrystalEffectRule } from './rules/GainCrystalEffectRule';
-import { MayChallengeRule } from './rules/MayChallengeRule';
+import { PlayCardEffectRule } from './rules/PlayCardEffectRule';
 import { PlayCardRule } from './rules/PlayCardRule';
-import { PlayerHelper } from './rules/PlayerHelper';
 import { PrepareNextRoundRule } from './rules/PrepareNextRoundRule';
+import { PutPowerTokenEffectRule } from './rules/PutPowerTokenEffectRule';
+import { ReturnCardEffectRule } from './rules/ReturnCardEffectRule';
 import { RuleId } from './rules/RuleId';
 import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
 import { StartRoundRule } from './rules/StartRoundRule';
+import { StashPowerTokensEffectRule } from './rules/StashPowerTokensEffectRule';
 import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
+import { StunCardRule } from './rules/StunCardRule';
 export class SkyriftRules extends SecretMaterialRules {
     rules = {
         [RuleId.StartRound]: StartRoundRule,
@@ -45,46 +39,41 @@ export class SkyriftRules extends SecretMaterialRules {
         [RuleId.EndPlayerTurn]: EndPlayerTurnRule,
         [RuleId.EndRound]: EndRoundRule,
         [RuleId.PrepareNextRound]: PrepareNextRoundRule,
-        [RuleId.MayChallenge]: MayChallengeRule,
-        [RuleId.Challenge]: ChallengeRule,
-        [RuleId.LoyalSquireEffect]: LoyalSquireEffectRule,
-        [RuleId.PrincessLithaEffect]: PrincessLithaEffectRule,
-        [RuleId.RobbinsMasterOfArmsEffect]: RobbinsMasterOfArmsEffectRule,
-        [RuleId.OzmaTheMageEffect]: OzmaTheMageEffectRule,
+        [RuleId.ChallengeEffect]: ChallengeEffectRule,
+        [RuleId.ChallengeResponse]: ChallengeResponseRule,
+        [RuleId.DrawEffect]: DrawEffectRule,
+        [RuleId.DiscardEffect]: DiscardEffectRule,
+        [RuleId.DestroyEffect]: DestroyEffectRule,
+        [RuleId.StunEffect]: StunCardRule,
+        [RuleId.ReturnCardEffect]: ReturnCardEffectRule,
+        [RuleId.PutPowerTokensEffect]: PutPowerTokenEffectRule,
+        [RuleId.StashPowerTokensEffect]: StashPowerTokensEffectRule,
+        [RuleId.GainCrystalEffect]: GainCrystalEffectRule,
+        [RuleId.StealCrystalEffect]: StealCrystalEffectRule,
+        [RuleId.AbiSnakeCharmerEffect]: AbiSnakeCharmerEffectRule,
+        [RuleId.PlayCardEffect]: PlayCardEffectRule,
         [RuleId.ArmadaEffect]: ArmadaEffectRule,
-        [RuleId.SoulBladeEffect]: SoulBladeEffectRule,
-        [RuleId.CoverOfNightEffect]: CoverOfNightEffectRule,
-        [RuleId.SacrificeEffect]: SacrificeEffectRule,
-        [RuleId.WatchTowerEffect]: WatchTowerEffectRule,
-        [RuleId.ConfluenceEffect]: DrawEffectRule,
-        [RuleId.HarvestEffect]: HarvestEffectRule,
-        [RuleId.SeaScorcherEffect]: SeaScorcherEffectRule,
-        [RuleId.AeliaSteadyHandEffect]: DrawEffectRule,
+        [RuleId.PrincessLithaEffect]: PrincessLithaEffectRule,
+        [RuleId.WindWrathEffect]: WindWrathEffectRule,
+        [RuleId.CavernSkulkerEffect]: CavernSkulkerEffectRule,
+        [RuleId.DoomEffect]: DoomEffectRule,
         [RuleId.EyeOfSkyEffect]: EyeOfSkyEffectRule,
-        [RuleId.TropicalRuffianEffect]: DiscardEffectRule,
-        [RuleId.RiggingRaidersEffect]: RiggingRaidersEffectRule,
-        [RuleId.OttoFactotumEffect]: OttoFactotumEffectRule,
-        [RuleId.OscarScullionEffect]: OscarScullionEffectRule,
-        [RuleId.TideRoverEffect]: TideRoverEffectRule,
-        [RuleId.LongJawsSilverEffect]: StealCrystalEffectRule,
-        [RuleId.FortunesCourseEffect]: GainCrystalEffectRule,
-        [RuleId.DarkArmageddonEffect]: DarkArmageddonEffectRule,
-        [RuleId.BoardingPartyEffect]: BoardingPartyEffectRule,
-        [RuleId.DawnsDoomEffect]: DawnsDoomEffectRule,
-        [RuleId.SurpriseLootEffect]: SurpriseLootEffectRule
+        [RuleId.BoardingPartyEffect]: BoardingPartyEffectRule
     };
     locationsStrategies = {
         [MaterialType.Card]: {
             [LocationType.PlayerDeck]: new PositiveSequenceStrategy(),
             [LocationType.PlayerHand]: new PositiveSequenceStrategy(),
             [LocationType.PlayArea]: new PositiveSequenceStrategy(),
-            [LocationType.PlayerDiscard]: new PositiveSequenceStrategy()
+            [LocationType.PlayerDiscard]: new PositiveSequenceStrategy(),
+            [LocationType.UnderCard]: new PositiveSequenceStrategy()
         }
     };
     hidingStrategies = {
         [MaterialType.Card]: {
             [LocationType.PlayerDeck]: hideFront,
-            [LocationType.PlayerHand]: hideFrontToOthers
+            [LocationType.PlayerHand]: hideFrontToOthers,
+            [LocationType.UnderCard]: hideFront
         }
     };
     play(move, context) {
@@ -98,18 +87,22 @@ export class SkyriftRules extends SecretMaterialRules {
         if (isMoveItemType(MaterialType.Card)(move)) {
             const origin = this.material(MaterialType.Card).getItem(move.itemIndex).location;
             if (origin.type === LocationType.PlayArea && move.location.type !== LocationType.PlayArea) {
-                const cardRule = new PlayerHelper(this.game).getCardRule(move.itemIndex);
-                moves.push(...cardRule.onLeave());
+                moves.push(...createCardRule(this.game, move.itemIndex).onLeaves());
+                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());
+                    moves.push(...createCardRule(this.game, itemIndex).onLeaves());
+                    leavingIndexes.push(itemIndex);
                 }
             }
+            if (leavingIndexes.length > 0) {
+                this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => !leavingIndexes.includes(e.cardIndex)));
+            }
         }
         return moves;
     }
@@ -145,6 +138,9 @@ export class SkyriftRules extends SecretMaterialRules {
         }
         return moves;
     }
+    isUnpredictableMove(move, player) {
+        return (isStartPlayerTurn(move) && move.id === RuleId.CavernSkulkerEffect) || super.isUnpredictableMove(move, player);
+    }
     giveTime() {
         return 60;
     }

package/dist/SkyriftSetup.js

@@ -1,8 +1,10 @@
 import { listingToList, MaterialGameSetup } from '@gamepark/rules-api';
 import { shuffle } from 'es-toolkit';
 import { Deck } from './Deck';
+import { GraveHurt } from './material/decks/GraveHurt';
 import { HearthBlade } from './material/decks/HearthBlade';
 import { HighWave } from './material/decks/HighWave';
+import { WindSands } from './material/decks/WindSands';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
 import { Memory } from './Memory';
@@ -10,6 +12,8 @@ import { RuleId } from './rules/RuleId';
 import { SkyriftRules } from './SkyriftRules';
 const deckConfigurations = {
     [Deck.HearthBlade]: HearthBlade,
+    [Deck.WindSands]: WindSands,
+    [Deck.GraveHurt]: GraveHurt,
     [Deck.HighWave]: HighWave
 };
 export class SkyriftSetup extends MaterialGameSetup {
@@ -17,6 +21,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,38 @@ 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,
+    MacabreLegion = 301,
+    CavernSkulker = 302,
+    TheGreatToady = 303,
+    Umbraboros = 304,
+    Nosferatis = 305,
+    InsatiableUmbraphage = 306,
+    ScrabDoombird = 307,
+    MoonFang = 308,
+    Whisperers = 309,
+    OstraVoiceOfTheSoul = 310,
+    TerrifyingSummoning = 311,
+    ReturnInTime = 312,
+    CallOfTheEclipse = 313,
+    WitchingHour = 314,
+    Doom = 315,
+    AstralHammer = 316,
     SeaScorcher = 601,
     AeliaSteadyHand = 602,
     EyeOfSky = 603,

package/dist/material/Card.js

@@ -16,6 +16,38 @@ 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["MacabreLegion"] = 301] = "MacabreLegion";
+    Card[Card["CavernSkulker"] = 302] = "CavernSkulker";
+    Card[Card["TheGreatToady"] = 303] = "TheGreatToady";
+    Card[Card["Umbraboros"] = 304] = "Umbraboros";
+    Card[Card["Nosferatis"] = 305] = "Nosferatis";
+    Card[Card["InsatiableUmbraphage"] = 306] = "InsatiableUmbraphage";
+    Card[Card["ScrabDoombird"] = 307] = "ScrabDoombird";
+    Card[Card["MoonFang"] = 308] = "MoonFang";
+    Card[Card["Whisperers"] = 309] = "Whisperers";
+    Card[Card["OstraVoiceOfTheSoul"] = 310] = "OstraVoiceOfTheSoul";
+    Card[Card["TerrifyingSummoning"] = 311] = "TerrifyingSummoning";
+    Card[Card["ReturnInTime"] = 312] = "ReturnInTime";
+    Card[Card["CallOfTheEclipse"] = 313] = "CallOfTheEclipse";
+    Card[Card["WitchingHour"] = 314] = "WitchingHour";
+    Card[Card["Doom"] = 315] = "Doom";
+    Card[Card["AstralHammer"] = 316] = "AstralHammer";
     Card[Card["SeaScorcher"] = 601] = "SeaScorcher";
     Card[Card["AeliaSteadyHand"] = 602] = "AeliaSteadyHand";
     Card[Card["EyeOfSky"] = 603] = "EyeOfSky";

package/dist/material/CardProperties.js

@@ -15,6 +15,38 @@ 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/windsands/AbiSnakeCharmer';
+import { AncientCurse } from './decks/windsands/AncientCurse';
+import { Catadjinn } from './decks/windsands/Catadjinn';
+import { DeathTrap } from './decks/windsands/DeathTrap';
+import { DesertRaider } from './decks/windsands/DesertRaider';
+import { DuneWardrums } from './decks/windsands/DuneWardrums';
+import { ErgDeathslayer } from './decks/windsands/ErgDeathslayer';
+import { MalikShadowtracker } from './decks/windsands/MalikShadowtracker';
+import { Metamorph } from './decks/windsands/Metamorph';
+import { MushaFakir } from './decks/windsands/MushaFakir';
+import { OasisShaman } from './decks/windsands/OasisShaman';
+import { SandWalkers } from './decks/windsands/SandWalkers';
+import { StarlightBazaar } from './decks/windsands/StarlightBazaar';
+import { Vandals } from './decks/windsands/Vandals';
+import { WindWrath } from './decks/windsands/WindWrath';
+import { WishLamp } from './decks/windsands/WishLamp';
+import { AstralHammer } from './decks/gravehurt/AstralHammer';
+import { CavernSkulker } from './decks/gravehurt/CavernSkulker';
+import { Doom } from './decks/gravehurt/Doom';
+import { CallOfTheEclipse } from './decks/gravehurt/CallOfTheEclipse';
+import { InsatiableUmbraphage } from './decks/gravehurt/InsatiableUmbraphage';
+import { MacabreLegion } from './decks/gravehurt/MacabreLegion';
+import { MoonFang } from './decks/gravehurt/MoonFang';
+import { Nosferatis } from './decks/gravehurt/Nosferatis';
+import { OstraVoiceOfTheSoul } from './decks/gravehurt/OstraVoiceOfTheSoul';
+import { ReturnInTime } from './decks/gravehurt/ReturnInTime';
+import { ScrabDoombird } from './decks/gravehurt/ScrabDoombird';
+import { TerrifyingSummoning } from './decks/gravehurt/TerrifyingSummoning';
+import { TheGreatToady } from './decks/gravehurt/TheGreatToady';
+import { Umbraboros } from './decks/gravehurt/Umbraboros';
+import { Whisperers } from './decks/gravehurt/Whisperers';
+import { WitchingHour } from './decks/gravehurt/WitchingHour';
 import { Armada } from './decks/heathblade/Armada';
 import { Confluence } from './decks/heathblade/Confluence';
 import { CoverOfNight } from './decks/heathblade/CoverOfNight';
@@ -48,6 +80,38 @@ 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.MacabreLegion]: MacabreLegion,
+    [Card.CavernSkulker]: CavernSkulker,
+    [Card.TheGreatToady]: TheGreatToady,
+    [Card.Umbraboros]: Umbraboros,
+    [Card.Nosferatis]: Nosferatis,
+    [Card.InsatiableUmbraphage]: InsatiableUmbraphage,
+    [Card.ScrabDoombird]: ScrabDoombird,
+    [Card.MoonFang]: MoonFang,
+    [Card.Whisperers]: Whisperers,
+    [Card.OstraVoiceOfTheSoul]: OstraVoiceOfTheSoul,
+    [Card.TerrifyingSummoning]: TerrifyingSummoning,
+    [Card.ReturnInTime]: ReturnInTime,
+    [Card.CallOfTheEclipse]: CallOfTheEclipse,
+    [Card.WitchingHour]: WitchingHour,
+    [Card.Doom]: Doom,
+    [Card.AstralHammer]: AstralHammer,
     [Card.SeaScorcher]: SeaScorcher,
     [Card.AeliaSteadyHand]: AeliaSteadyHand,
     [Card.EyeOfSky]: EyeOfSky,

package/dist/material/CardRule.d.ts

@@ -1,36 +1,41 @@
 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 { Effect } from './Effect';
+import { OngoingEffectType } from './OngoingEffect';
 export declare class CardRule extends MaterialRulesPart {
     index: number;
     constructor(game: MaterialGame, index: number);
-    onEnters(): MaterialMove[];
-    onPlayerTurnStart(_player: Deck): MaterialMove[];
-    onRoundEnd(win: boolean): MaterialMove[];
-    onWinRound(): MaterialMove[];
-    onLoseRound(): MaterialMove[];
-    onCardEnters(_card: Card, _side: Deck): MaterialMove[];
-    oncePerTurnEffect: boolean;
-    entersEffect: boolean;
-    challenge: boolean;
-    onChallengeAccepted(): import("@gamepark/rules-api").CustomMove[];
-    onChallengeDeclined(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.EndRound>[];
-    onLeave(): MaterialMove[];
-    removePowerTokens(): import("@gamepark/rules-api").DeleteItem<number>[];
-    removeStunTokens(): import("@gamepark/rules-api").DeleteItem<number>[];
+    onEnters?(): void;
+    onCardEnters?(card: Card, side: Deck): void;
+    activate?(): void;
+    onPlayerTurnStart?(): void;
+    onFoeTurnStart?(): void;
+    onSkirmishEnd?(): void;
+    onSkirmishWin?(): void;
+    onSkirmishLost?(): void;
+    survivesSkirmish?(): boolean;
+    canActivate(): boolean;
+    onLeaves(): MaterialMove[];
+    removePowerTokens(): MaterialMove[];
+    removeStunTokens(): MaterialMove[];
+    removeSpecialTokens(): MaterialMove[];
     get item(): import("@gamepark/rules-api").MaterialItem<number, number, CardId>;
     get card(): Card;
     get properties(): import("./CardProperties").CardProperties;
+    get playArea(): import("@gamepark/rules-api").Material<number, number, number>;
+    get creatures(): import("@gamepark/rules-api").Material<number, number, number>;
     isStunned(): boolean;
     getPower(): number;
     getPowerIfNotStunned(): number;
-    addPendingEffect(): void;
+    addPendingEffect(ruleId: number): void;
+    addOngoingEffect(type: OngoingEffectType): void;
+    removeOngoingEffect(type: OngoingEffectType): void;
     get player(): number;
-    get opponent(): number;
-    startEffect(): MaterialMove[];
+    get foe(): number;
+    startEffect(effect: Effect): MaterialMove[];
+    getEffectPlayer(_effect: Effect): number;
     canBePlayed(): boolean;
-    permanentEffectTag?: CardTag;
-    hasPermanentEffectOnTag(tag: CardTag): boolean;
+    canSuitBePlayed(): boolean;
+    ongoingEffectPreventsPlayCard(): boolean;
 }