@gamepark/skyrift 0.1.0

package/dist/CustomMoveType.d.ts

@@ -0,0 +1,9 @@
+export declare enum CustomMoveType {
+    ConcedeRound = 1,
+    Draw = 2,
+    ChoosePlayer = 3,
+    EndEffect = 4,
+    Pass = 5,
+    Challenge = 6,
+    ActivateCard = 7
+}

package/dist/CustomMoveType.js

@@ -0,0 +1,10 @@
+export var CustomMoveType;
+(function (CustomMoveType) {
+    CustomMoveType[CustomMoveType["ConcedeRound"] = 1] = "ConcedeRound";
+    CustomMoveType[CustomMoveType["Draw"] = 2] = "Draw";
+    CustomMoveType[CustomMoveType["ChoosePlayer"] = 3] = "ChoosePlayer";
+    CustomMoveType[CustomMoveType["EndEffect"] = 4] = "EndEffect";
+    CustomMoveType[CustomMoveType["Pass"] = 5] = "Pass";
+    CustomMoveType[CustomMoveType["Challenge"] = 6] = "Challenge";
+    CustomMoveType[CustomMoveType["ActivateCard"] = 7] = "ActivateCard";
+})(CustomMoveType || (CustomMoveType = {}));

package/dist/Deck.d.ts

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

package/dist/Deck.js

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

package/dist/Memory.d.ts

@@ -0,0 +1,10 @@
+export declare enum Memory {
+    CrystalsToWin = 1,
+    CardsPlayed = 2,
+    Suit = 3,
+    PendingEffects = 4,
+    OncePerTurnEffects = 5,
+    CurrentPlayer = 6,
+    NextRoundStartPlayer = 7,
+    EffectCount = 8
+}

package/dist/Memory.js

@@ -0,0 +1,11 @@
+export var Memory;
+(function (Memory) {
+    Memory[Memory["CrystalsToWin"] = 1] = "CrystalsToWin";
+    Memory[Memory["CardsPlayed"] = 2] = "CardsPlayed";
+    Memory[Memory["Suit"] = 3] = "Suit";
+    Memory[Memory["PendingEffects"] = 4] = "PendingEffects";
+    Memory[Memory["OncePerTurnEffects"] = 5] = "OncePerTurnEffects";
+    Memory[Memory["CurrentPlayer"] = 6] = "CurrentPlayer";
+    Memory[Memory["NextRoundStartPlayer"] = 7] = "NextRoundStartPlayer";
+    Memory[Memory["EffectCount"] = 8] = "EffectCount";
+})(Memory || (Memory = {}));

package/dist/SkyriftOptions.d.ts

@@ -0,0 +1,10 @@
+import { OptionsSpec } from '@gamepark/rules-api';
+import { Deck } from './Deck';
+type PlayerOptions = {
+    id: Deck;
+};
+export type SkyriftOptions = {
+    players: PlayerOptions[];
+};
+export declare const SkyriftOptionsSpec: OptionsSpec<SkyriftOptions>;
+export {};

package/dist/SkyriftOptions.js

@@ -0,0 +1,11 @@
+import { getEnumValues } from '@gamepark/rules-api';
+import { Deck } from './Deck';
+export const SkyriftOptionsSpec = {
+    players: {
+        id: {
+            label: (t) => t('player.id'),
+            values: getEnumValues(Deck),
+            valueSpec: (id) => ({ label: (t) => t(`player.${id}`) })
+        }
+    }
+};

package/dist/SkyriftRules.d.ts

@@ -0,0 +1,90 @@
+import { CustomMove, ItemMove, MaterialGame, MaterialMove, MaterialMoveRandomized, MaterialMoveView, PlayMoveContext, PositiveSequenceStrategy, SecretMaterialRules, TimeLimit } from '@gamepark/rules-api';
+import { Deck } from './Deck';
+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 { DarkBlazerEffectRule } from './material/decks/highwave/DarkBlazerEffectRule';
+import { DawnsDoomEffectRule } from './material/decks/highwave/DawnsDoomEffectRule';
+import { OttoPouchyEffectRule } from './material/decks/highwave/OttoPouchyEffectRule';
+import { PowderMonkeyEffectRule } from './material/decks/highwave/PowderMonkeyEffectRule';
+import { RicoSkeyeEffectRule } from './material/decks/highwave/RicoSkeyeEffectRule';
+import { SaltyDogEffectRule } from './material/decks/highwave/SaltyDogEffectRule';
+import { ScallywagEffectRule } from './material/decks/highwave/ScallywagEffectRule';
+import { SkupperEffectRule } from './material/decks/highwave/SkupperEffectRule';
+import { SurpriseLootEffectRule } from './material/decks/highwave/SurpriseLootEffectRule';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { ChallengeRule } from './rules/ChallengeRule';
+import { DiscardEffectRule } from './rules/DiscardEffectRule';
+import { DrawEffectRule } from './rules/DrawEffectRule';
+import { EndRoundRule } from './rules/EndRoundRule';
+import { GainCrystalEffectRule } from './rules/GainCrystalEffectRule';
+import { MayChallengeRule } from './rules/MayChallengeRule';
+import { PlayCardRule } from './rules/PlayCardRule';
+import { PrepareNextRoundRule } from './rules/PrepareNextRoundRule';
+import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
+import { StartRoundRule } from './rules/StartRoundRule';
+import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
+export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType, LocationType> implements TimeLimit<MaterialGame<Deck, MaterialType, LocationType>, MaterialMove<Deck, MaterialType, LocationType>, Deck> {
+    rules: {
+        1: typeof StartRoundRule;
+        2: typeof StartPlayerTurnRule;
+        3: typeof PlayCardRule;
+        4: typeof EndRoundRule;
+        5: typeof PrepareNextRoundRule;
+        6: typeof MayChallengeRule;
+        7: typeof ChallengeRule;
+        102: typeof LoyalSquireEffectRule;
+        103: typeof PrincessLithaEffectRule;
+        104: typeof RobbinsMasterOfArmsEffectRule;
+        109: typeof OzmaTheMageEffectRule;
+        110: typeof ArmadaEffectRule;
+        111: typeof SoulBladeEffectRule;
+        112: typeof CoverOfNightEffectRule;
+        113: typeof SacrificeEffectRule;
+        114: typeof WatchTowerEffectRule;
+        115: typeof DrawEffectRule;
+        116: typeof HarvestEffectRule;
+        601: typeof PowderMonkeyEffectRule;
+        602: typeof DrawEffectRule;
+        603: typeof RicoSkeyeEffectRule;
+        605: typeof DiscardEffectRule;
+        606: typeof ScallywagEffectRule;
+        607: typeof OttoPouchyEffectRule;
+        608: typeof SkupperEffectRule;
+        609: typeof SaltyDogEffectRule;
+        610: typeof StealCrystalEffectRule;
+        612: typeof GainCrystalEffectRule;
+        613: typeof DarkBlazerEffectRule;
+        614: typeof BoardingPartyEffectRule;
+        615: typeof DawnsDoomEffectRule;
+        616: typeof SurpriseLootEffectRule;
+    };
+    locationsStrategies: {
+        1: {
+            1: PositiveSequenceStrategy<number, number, number>;
+            2: PositiveSequenceStrategy<number, number, number>;
+            7: PositiveSequenceStrategy<number, number, number>;
+            8: PositiveSequenceStrategy<number, number, number>;
+        };
+    };
+    hidingStrategies: {
+        1: {
+            1: import("@gamepark/rules-api").HidingStrategy<number, number>;
+            2: import("@gamepark/rules-api").HidingStrategy;
+        };
+    };
+    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>[];
+    giveTime(): number;
+}

package/dist/SkyriftRules.js

@@ -0,0 +1,140 @@
+import { hideFront, hideFrontToOthers, isMoveItemType, MoveKind, PositiveSequenceStrategy, SecretMaterialRules } from '@gamepark/rules-api';
+import { CustomMoveType } from './CustomMoveType';
+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 { DarkBlazerEffectRule } from './material/decks/highwave/DarkBlazerEffectRule';
+import { DawnsDoomEffectRule } from './material/decks/highwave/DawnsDoomEffectRule';
+import { OttoPouchyEffectRule } from './material/decks/highwave/OttoPouchyEffectRule';
+import { PowderMonkeyEffectRule } from './material/decks/highwave/PowderMonkeyEffectRule';
+import { RicoSkeyeEffectRule } from './material/decks/highwave/RicoSkeyeEffectRule';
+import { SaltyDogEffectRule } from './material/decks/highwave/SaltyDogEffectRule';
+import { ScallywagEffectRule } from './material/decks/highwave/ScallywagEffectRule';
+import { SkupperEffectRule } from './material/decks/highwave/SkupperEffectRule';
+import { SurpriseLootEffectRule } from './material/decks/highwave/SurpriseLootEffectRule';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { Memory } from './Memory';
+import { ChallengeRule } from './rules/ChallengeRule';
+import { DiscardEffectRule } from './rules/DiscardEffectRule';
+import { DrawEffectRule } from './rules/DrawEffectRule';
+import { EndRoundRule } from './rules/EndRoundRule';
+import { GainCrystalEffectRule } from './rules/GainCrystalEffectRule';
+import { MayChallengeRule } from './rules/MayChallengeRule';
+import { PlayCardRule } from './rules/PlayCardRule';
+import { PlayerHelper } from './rules/PlayerHelper';
+import { PrepareNextRoundRule } from './rules/PrepareNextRoundRule';
+import { RuleId } from './rules/RuleId';
+import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
+import { StartRoundRule } from './rules/StartRoundRule';
+import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
+export class SkyriftRules extends SecretMaterialRules {
+    rules = {
+        [RuleId.StartRound]: StartRoundRule,
+        [RuleId.StartPlayerTurn]: StartPlayerTurnRule,
+        [RuleId.PlayCard]: PlayCardRule,
+        [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.ArmadaEffect]: ArmadaEffectRule,
+        [RuleId.SoulBladeEffect]: SoulBladeEffectRule,
+        [RuleId.CoverOfNightEffect]: CoverOfNightEffectRule,
+        [RuleId.SacrificeEffect]: SacrificeEffectRule,
+        [RuleId.WatchTowerEffect]: WatchTowerEffectRule,
+        [RuleId.ConfluenceEffect]: DrawEffectRule,
+        [RuleId.HarvestEffect]: HarvestEffectRule,
+        [RuleId.PowderMonkeyEffect]: PowderMonkeyEffectRule,
+        [RuleId.AeliaSteadyHandEffect]: DrawEffectRule,
+        [RuleId.RicoSkeyeEffect]: RicoSkeyeEffectRule,
+        [RuleId.TropicalRuffianEffect]: DiscardEffectRule,
+        [RuleId.ScallywagEffect]: ScallywagEffectRule,
+        [RuleId.OttoPouchyEffect]: OttoPouchyEffectRule,
+        [RuleId.SkupperEffect]: SkupperEffectRule,
+        [RuleId.SaltyDogEffect]: SaltyDogEffectRule,
+        [RuleId.LongJawsSilverEffect]: StealCrystalEffectRule,
+        [RuleId.TreasureMapEffect]: GainCrystalEffectRule,
+        [RuleId.DarkBlazerEffect]: DarkBlazerEffectRule,
+        [RuleId.BoardingPartyEffect]: BoardingPartyEffectRule,
+        [RuleId.DawnsDoomEffect]: DawnsDoomEffectRule,
+        [RuleId.SurpriseLootEffect]: SurpriseLootEffectRule
+    };
+    locationsStrategies = {
+        [MaterialType.Card]: {
+            [LocationType.PlayerDeck]: new PositiveSequenceStrategy(),
+            [LocationType.PlayerHand]: new PositiveSequenceStrategy(),
+            [LocationType.PlayArea]: new PositiveSequenceStrategy(),
+            [LocationType.PlayerDiscard]: new PositiveSequenceStrategy()
+        }
+    };
+    hidingStrategies = {
+        [MaterialType.Card]: {
+            [LocationType.PlayerDeck]: hideFront,
+            [LocationType.PlayerHand]: hideFrontToOthers
+        }
+    };
+    play(move, context) {
+        if (move.kind !== MoveKind.LocalMove && this.material(MaterialType.Crystal).getQuantity() > 0 && this.isOver()) {
+            return [];
+        }
+        return super.play(move, context);
+    }
+    beforeItemMove(move) {
+        const moves = super.beforeItemMove(move);
+        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);
+                if (!cardRule.isStunned()) {
+                    moves.push(...cardRule.onLeave());
+                }
+            }
+        }
+        return moves;
+    }
+    afterItemMove(move, context) {
+        const moves = super.afterItemMove(move, context);
+        if (isMoveItemType(MaterialType.Crystal)(move) && move.location.type === LocationType.PlayerCrystals) {
+            const playerCrystal = this.material(MaterialType.Crystal).location(LocationType.PlayerCrystals).player(move.location.player).getQuantity();
+            if (playerCrystal >= this.remind(Memory.CrystalsToWin)) {
+                moves.push(this.endGame());
+            }
+        }
+        return moves;
+    }
+    onCustomMove(move, context) {
+        const moves = super.onCustomMove(move, context);
+        if (move.type === CustomMoveType.Draw) {
+            const { player, quantity } = move.data;
+            const deck = this.material(MaterialType.Card).location(LocationType.PlayerDeck).player(player).deck();
+            if (deck.length >= quantity) {
+                moves.push(...deck.deal({ type: LocationType.PlayerHand, player }, quantity));
+            }
+            else {
+                if (deck.length > 0) {
+                    moves.push(...deck.moveItems({ type: LocationType.PlayerHand, player }));
+                }
+                const discard = this.material(MaterialType.Card).location(LocationType.PlayerDiscard).player(player);
+                moves.push(discard.moveItemsAtOnce({ type: LocationType.PlayerDeck, player }));
+                moves.push(discard.shuffle());
+                moves.push(this.customMove(CustomMoveType.Draw, { player, quantity: quantity - deck.length }));
+            }
+        }
+        return moves;
+    }
+    giveTime() {
+        return 60;
+    }
+}

package/dist/SkyriftSetup.d.ts

@@ -0,0 +1,12 @@
+import { MaterialGameSetup } from '@gamepark/rules-api';
+import { Deck } from './Deck';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { SkyriftOptions } from './SkyriftOptions';
+import { SkyriftRules } from './SkyriftRules';
+export declare class SkyriftSetup extends MaterialGameSetup<Deck, MaterialType, LocationType, SkyriftOptions> {
+    Rules: typeof SkyriftRules;
+    setupMaterial(_options: SkyriftOptions): void;
+    setupDecks(): void;
+    start(): void;
+}

package/dist/SkyriftSetup.js

@@ -0,0 +1,40 @@
+import { listingToList, MaterialGameSetup } from '@gamepark/rules-api';
+import { shuffle } from 'es-toolkit';
+import { Deck } from './Deck';
+import { HearthBlade } from './material/decks/HearthBlade';
+import { HighWave } from './material/decks/HighWave';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { Memory } from './Memory';
+import { RuleId } from './rules/RuleId';
+import { SkyriftRules } from './SkyriftRules';
+const deckConfigurations = {
+    [Deck.HearthBlade]: HearthBlade,
+    [Deck.HighWave]: HighWave
+};
+export class SkyriftSetup extends MaterialGameSetup {
+    Rules = SkyriftRules;
+    setupMaterial(_options) {
+        this.setupDecks();
+        this.memorize(Memory.PendingEffects, []);
+        this.memorize(Memory.CrystalsToWin, 6);
+    }
+    setupDecks() {
+        for (const player of this.players) {
+            const deckConfig = deckConfigurations[player];
+            const cardIds = listingToList(deckConfig);
+            const cards = cardIds.map(card => ({
+                id: { front: card, back: player },
+                location: {
+                    type: LocationType.PlayerDeck,
+                    player
+                }
+            }));
+            this.material(MaterialType.Card).createItemsAtOnce(shuffle(cards));
+            this.material(MaterialType.Card).player(player).deck().deal({ type: LocationType.PlayerHand, player }, 6);
+        }
+    }
+    start() {
+        this.startPlayerTurn(RuleId.StartRound, this.players[0]);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SkyriftRules } from './SkyriftRules';
+export { SkyriftOptionsSpec } from './SkyriftOptions';
+export { SkyriftSetup } from './SkyriftSetup';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { SkyriftRules } from './SkyriftRules';
+export { SkyriftOptionsSpec } from './SkyriftOptions';
+export { SkyriftSetup } from './SkyriftSetup';

package/dist/material/Card.d.ts

@@ -0,0 +1,39 @@
+import { Deck } from '../Deck';
+export declare enum Card {
+    HedgeKnight = 101,
+    LoyalSquire = 102,
+    PrincessLitha = 103,
+    RobbinsMasterOfArms = 104,
+    Nightguard = 105,
+    Shadowbolt = 106,
+    ElaraBlazingArrow = 107,
+    WoodSlinger = 108,
+    OzmaTheMage = 109,
+    Armada = 110,
+    SoulBlade = 111,
+    CoverOfNight = 112,
+    Sacrifice = 113,
+    WatchTower = 114,
+    Confluence = 115,
+    Harvest = 116,
+    PowderMonkey = 601,
+    AeliaSteadyHand = 602,
+    RicoSkeye = 603,
+    MistyGunner = 604,
+    TropicalRuffian = 605,
+    Scallywag = 606,
+    OttoPouchy = 607,
+    Skupper = 608,
+    SaltyDog = 609,
+    LongJawsSilver = 610,
+    BrassDragon = 611,
+    TreasureMap = 612,
+    DarkBlazer = 613,
+    BoardingParty = 614,
+    DawnsDoom = 615,
+    SurpriseLoot = 616
+}
+export type CardId = {
+    front?: Card;
+    back: Deck;
+};

package/dist/material/Card.js

@@ -0,0 +1,35 @@
+export var Card;
+(function (Card) {
+    Card[Card["HedgeKnight"] = 101] = "HedgeKnight";
+    Card[Card["LoyalSquire"] = 102] = "LoyalSquire";
+    Card[Card["PrincessLitha"] = 103] = "PrincessLitha";
+    Card[Card["RobbinsMasterOfArms"] = 104] = "RobbinsMasterOfArms";
+    Card[Card["Nightguard"] = 105] = "Nightguard";
+    Card[Card["Shadowbolt"] = 106] = "Shadowbolt";
+    Card[Card["ElaraBlazingArrow"] = 107] = "ElaraBlazingArrow";
+    Card[Card["WoodSlinger"] = 108] = "WoodSlinger";
+    Card[Card["OzmaTheMage"] = 109] = "OzmaTheMage";
+    Card[Card["Armada"] = 110] = "Armada";
+    Card[Card["SoulBlade"] = 111] = "SoulBlade";
+    Card[Card["CoverOfNight"] = 112] = "CoverOfNight";
+    Card[Card["Sacrifice"] = 113] = "Sacrifice";
+    Card[Card["WatchTower"] = 114] = "WatchTower";
+    Card[Card["Confluence"] = 115] = "Confluence";
+    Card[Card["Harvest"] = 116] = "Harvest";
+    Card[Card["PowderMonkey"] = 601] = "PowderMonkey";
+    Card[Card["AeliaSteadyHand"] = 602] = "AeliaSteadyHand";
+    Card[Card["RicoSkeye"] = 603] = "RicoSkeye";
+    Card[Card["MistyGunner"] = 604] = "MistyGunner";
+    Card[Card["TropicalRuffian"] = 605] = "TropicalRuffian";
+    Card[Card["Scallywag"] = 606] = "Scallywag";
+    Card[Card["OttoPouchy"] = 607] = "OttoPouchy";
+    Card[Card["Skupper"] = 608] = "Skupper";
+    Card[Card["SaltyDog"] = 609] = "SaltyDog";
+    Card[Card["LongJawsSilver"] = 610] = "LongJawsSilver";
+    Card[Card["BrassDragon"] = 611] = "BrassDragon";
+    Card[Card["TreasureMap"] = 612] = "TreasureMap";
+    Card[Card["DarkBlazer"] = 613] = "DarkBlazer";
+    Card[Card["BoardingParty"] = 614] = "BoardingParty";
+    Card[Card["DawnsDoom"] = 615] = "DawnsDoom";
+    Card[Card["SurpriseLoot"] = 616] = "SurpriseLoot";
+})(Card || (Card = {}));

package/dist/material/CardProperties.d.ts

@@ -0,0 +1,14 @@
+import { MaterialGame } from '@gamepark/rules-api';
+import { Card } from './Card';
+import { CardRule } from './CardRule';
+import { CardSuit } from './CardSuit';
+import { CardTag } from './CardTag';
+import { CardType } from './CardType';
+export type CardProperties = {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    tag?: CardTag;
+    rule: new (game: MaterialGame, index: number) => CardRule;
+};
+export declare const cardProperties: Record<Card, CardProperties>;

package/dist/material/CardProperties.js

@@ -0,0 +1,67 @@
+import { Card } from './Card';
+import { AeliaSteadyHand } from './decks/highwave/AeliaSteadyHand';
+import { BoardingParty } from './decks/highwave/BoardingParty';
+import { BrassDragon } from './decks/highwave/BrassDragon';
+import { DarkBlazer } from './decks/highwave/DarkBlazer';
+import { DawnsDoom } from './decks/highwave/DawnsDoom';
+import { LongJawsSilver } from './decks/highwave/LongJawsSilver';
+import { MistyGunner } from './decks/highwave/MistyGunner';
+import { OttoPouchy } from './decks/highwave/OttoPouchy';
+import { PowderMonkey } from './decks/highwave/PowderMonkey';
+import { RicoSkeye } from './decks/highwave/RicoSkeye';
+import { SaltyDog } from './decks/highwave/SaltyDog';
+import { Scallywag } from './decks/highwave/Scallywag';
+import { Skupper } from './decks/highwave/Skupper';
+import { SurpriseLoot } from './decks/highwave/SurpriseLoot';
+import { TreasureMap } from './decks/highwave/TreasureMap';
+import { TropicalRuffian } from './decks/highwave/TropicalRuffian';
+import { Armada } from './decks/heathblade/Armada';
+import { Confluence } from './decks/heathblade/Confluence';
+import { CoverOfNight } from './decks/heathblade/CoverOfNight';
+import { ElaraBlazingArrow } from './decks/heathblade/ElaraBlazingArrow';
+import { Harvest } from './decks/heathblade/Harvest';
+import { HedgeKnight } from './decks/heathblade/HedgeKnight';
+import { LoyalSquire } from './decks/heathblade/LoyalSquire';
+import { Nightguard } from './decks/heathblade/Nightguard';
+import { OzmaTheMage } from './decks/heathblade/OzmaTheMage';
+import { PrincessLitha } from './decks/heathblade/PrincessLitha';
+import { RobbinsMasterOfArms } from './decks/heathblade/RobbinsMasterOfArms';
+import { Sacrifice } from './decks/heathblade/Sacrifice';
+import { Shadowbolt } from './decks/heathblade/Shadowbolt';
+import { SoulBlade } from './decks/heathblade/SoulBlade';
+import { WatchTower } from './decks/heathblade/WatchTower';
+import { WoodSlinger } from './decks/heathblade/WoodSlinger';
+export const cardProperties = {
+    [Card.HedgeKnight]: HedgeKnight,
+    [Card.LoyalSquire]: LoyalSquire,
+    [Card.PrincessLitha]: PrincessLitha,
+    [Card.RobbinsMasterOfArms]: RobbinsMasterOfArms,
+    [Card.Nightguard]: Nightguard,
+    [Card.Shadowbolt]: Shadowbolt,
+    [Card.ElaraBlazingArrow]: ElaraBlazingArrow,
+    [Card.WoodSlinger]: WoodSlinger,
+    [Card.OzmaTheMage]: OzmaTheMage,
+    [Card.Armada]: Armada,
+    [Card.SoulBlade]: SoulBlade,
+    [Card.CoverOfNight]: CoverOfNight,
+    [Card.Sacrifice]: Sacrifice,
+    [Card.WatchTower]: WatchTower,
+    [Card.Confluence]: Confluence,
+    [Card.Harvest]: Harvest,
+    [Card.PowderMonkey]: PowderMonkey,
+    [Card.AeliaSteadyHand]: AeliaSteadyHand,
+    [Card.RicoSkeye]: RicoSkeye,
+    [Card.MistyGunner]: MistyGunner,
+    [Card.TropicalRuffian]: TropicalRuffian,
+    [Card.Scallywag]: Scallywag,
+    [Card.OttoPouchy]: OttoPouchy,
+    [Card.Skupper]: Skupper,
+    [Card.SaltyDog]: SaltyDog,
+    [Card.LongJawsSilver]: LongJawsSilver,
+    [Card.BrassDragon]: BrassDragon,
+    [Card.TreasureMap]: TreasureMap,
+    [Card.DarkBlazer]: DarkBlazer,
+    [Card.BoardingParty]: BoardingParty,
+    [Card.DawnsDoom]: DawnsDoom,
+    [Card.SurpriseLoot]: SurpriseLoot
+};

package/dist/material/CardRule.d.ts

@@ -0,0 +1,36 @@
+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';
+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>[];
+    get item(): import("@gamepark/rules-api").MaterialItem<number, number, CardId>;
+    get card(): Card;
+    get properties(): import("./CardProperties").CardProperties;
+    isStunned(): boolean;
+    getPower(): number;
+    getPowerIfNotStunned(): number;
+    addPendingEffect(): void;
+    get player(): number;
+    get opponent(): number;
+    startEffect(): MaterialMove[];
+    canBePlayed(): boolean;
+    permanentEffectTag?: CardTag;
+    hasPermanentEffectOnTag(tag: CardTag): boolean;
+}