@gamepark/skyrift 0.1.0

package/dist/material/CardRule.js

@@ -0,0 +1,113 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { Memory } from '../Memory';
+import { RuleId } from '../rules/RuleId';
+import { cardProperties } from './CardProperties';
+import { CardSuit } from './CardSuit';
+import { LocationType } from './LocationType';
+import { MaterialType } from './MaterialType';
+export class CardRule extends MaterialRulesPart {
+    index;
+    constructor(game, index) {
+        super(game);
+        this.index = index;
+    }
+    onEnters() {
+        if (this.entersEffect || this.challenge) {
+            this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index, challenge: this.challenge }]);
+        }
+        return [];
+    }
+    onPlayerTurnStart(_player) {
+        return [];
+    }
+    onRoundEnd(win) {
+        return win ? this.onWinRound() : this.onLoseRound();
+    }
+    onWinRound() {
+        return [];
+    }
+    onLoseRound() {
+        return [];
+    }
+    onCardEnters(_card, _side) {
+        return [];
+    }
+    oncePerTurnEffect = false;
+    entersEffect = false;
+    challenge = false;
+    onChallengeAccepted() {
+        return [this.customMove(CustomMoveType.EndEffect)];
+    }
+    onChallengeDeclined() {
+        this.memorize(Memory.PendingEffects, []);
+        return [this.startPlayerTurn(RuleId.EndRound, this.opponent)];
+    }
+    onLeave() {
+        return [...this.removePowerTokens(), ...this.removeStunTokens()];
+    }
+    removePowerTokens() {
+        const tokens = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index);
+        return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
+    }
+    removeStunTokens() {
+        const tokens = this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index);
+        return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
+    }
+    get item() {
+        return this.material(MaterialType.Card).getItem(this.index);
+    }
+    get card() {
+        return this.item.id.front;
+    }
+    get properties() {
+        return cardProperties[this.card];
+    }
+    isStunned() {
+        return this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index).getQuantity() > 0;
+    }
+    getPower() {
+        if (this.isStunned()) {
+            return 0;
+        }
+        else {
+            return this.getPowerIfNotStunned();
+        }
+    }
+    getPowerIfNotStunned() {
+        const basePower = this.properties.power;
+        const powerTokensCount = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index).getQuantity();
+        return basePower + powerTokensCount;
+    }
+    addPendingEffect() {
+        this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index }]);
+    }
+    get player() {
+        return this.item.location.player;
+    }
+    get opponent() {
+        return this.game.players.find((p) => p !== this.player);
+    }
+    startEffect() {
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        if (!pendingEffects.length) {
+            pendingEffects.push({ cardIndex: this.index });
+        }
+        const effect = pendingEffects[0];
+        if (effect.challenge) {
+            return [this.startPlayerTurn(RuleId.MayChallenge, this.player)];
+        }
+        else {
+            return [this.startPlayerTurn(this.card, this.player)];
+        }
+    }
+    canBePlayed() {
+        const currentSuit = this.remind(Memory.Suit);
+        const cardSuit = this.properties.suit;
+        return !(cardSuit === CardSuit.Night && currentSuit === CardSuit.Day) && !(cardSuit === CardSuit.Day && currentSuit === CardSuit.Night);
+    }
+    permanentEffectTag = undefined;
+    hasPermanentEffectOnTag(tag) {
+        return this.permanentEffectTag === tag && !this.isStunned();
+    }
+}

package/dist/material/CardSuit.d.ts

@@ -0,0 +1,5 @@
+export declare enum CardSuit {
+    Day = 1,
+    Night = 2,
+    Twilight = 3
+}

package/dist/material/CardSuit.js

@@ -0,0 +1,6 @@
+export var CardSuit;
+(function (CardSuit) {
+    CardSuit[CardSuit["Day"] = 1] = "Day";
+    CardSuit[CardSuit["Night"] = 2] = "Night";
+    CardSuit[CardSuit["Twilight"] = 3] = "Twilight";
+})(CardSuit || (CardSuit = {}));

package/dist/material/CardTag.d.ts

@@ -0,0 +1,5 @@
+export declare enum CardTag {
+    Knight = 1,
+    Archer = 2,
+    Cannon = 3
+}

package/dist/material/CardTag.js

@@ -0,0 +1,6 @@
+export var CardTag;
+(function (CardTag) {
+    CardTag[CardTag["Knight"] = 1] = "Knight";
+    CardTag[CardTag["Archer"] = 2] = "Archer";
+    CardTag[CardTag["Cannon"] = 3] = "Cannon";
+})(CardTag || (CardTag = {}));

package/dist/material/CardType.d.ts

@@ -0,0 +1,4 @@
+export declare enum CardType {
+    Creature = 1,
+    Action = 2
+}

package/dist/material/CardType.js

@@ -0,0 +1,5 @@
+export var CardType;
+(function (CardType) {
+    CardType[CardType["Creature"] = 1] = "Creature";
+    CardType[CardType["Action"] = 2] = "Action";
+})(CardType || (CardType = {}));

package/dist/material/Effect.d.ts

@@ -0,0 +1,4 @@
+export type Effect = {
+    cardIndex: number;
+    challenge?: boolean;
+};

package/dist/material/Effect.js

@@ -0,0 +1 @@
+export {};

package/dist/material/LocationType.d.ts

@@ -0,0 +1,14 @@
+export declare enum LocationType {
+    PlayerDeck = 1,
+    PlayerHand = 2,
+    CrystalStock = 3,
+    PowerTokenStock = 4,
+    StunTokenStock = 5,
+    Stake = 6,
+    PlayArea = 7,
+    PlayerDiscard = 8,
+    PlayerCrystals = 9,
+    CardPowerTokens = 10,
+    CardStunTokens = 11,
+    PlayerStash = 12
+}

package/dist/material/LocationType.js

@@ -0,0 +1,15 @@
+export var LocationType;
+(function (LocationType) {
+    LocationType[LocationType["PlayerDeck"] = 1] = "PlayerDeck";
+    LocationType[LocationType["PlayerHand"] = 2] = "PlayerHand";
+    LocationType[LocationType["CrystalStock"] = 3] = "CrystalStock";
+    LocationType[LocationType["PowerTokenStock"] = 4] = "PowerTokenStock";
+    LocationType[LocationType["StunTokenStock"] = 5] = "StunTokenStock";
+    LocationType[LocationType["Stake"] = 6] = "Stake";
+    LocationType[LocationType["PlayArea"] = 7] = "PlayArea";
+    LocationType[LocationType["PlayerDiscard"] = 8] = "PlayerDiscard";
+    LocationType[LocationType["PlayerCrystals"] = 9] = "PlayerCrystals";
+    LocationType[LocationType["CardPowerTokens"] = 10] = "CardPowerTokens";
+    LocationType[LocationType["CardStunTokens"] = 11] = "CardStunTokens";
+    LocationType[LocationType["PlayerStash"] = 12] = "PlayerStash";
+})(LocationType || (LocationType = {}));

package/dist/material/MaterialType.d.ts

@@ -0,0 +1,6 @@
+export declare enum MaterialType {
+    Card = 1,
+    Crystal = 2,
+    PowerToken = 3,
+    StunToken = 4
+}

package/dist/material/MaterialType.js

@@ -0,0 +1,7 @@
+export var MaterialType;
+(function (MaterialType) {
+    MaterialType[MaterialType["Card"] = 1] = "Card";
+    MaterialType[MaterialType["Crystal"] = 2] = "Crystal";
+    MaterialType[MaterialType["PowerToken"] = 3] = "PowerToken";
+    MaterialType[MaterialType["StunToken"] = 4] = "StunToken";
+})(MaterialType || (MaterialType = {}));

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

@@ -0,0 +1,18 @@
+export declare const HearthBlade: {
+    101: number;
+    102: number;
+    103: number;
+    104: number;
+    105: number;
+    106: number;
+    107: number;
+    108: number;
+    109: number;
+    110: number;
+    111: number;
+    112: number;
+    113: number;
+    114: number;
+    115: number;
+    116: number;
+};

package/dist/material/decks/HearthBlade.js

@@ -0,0 +1,19 @@
+import { Card } from '../Card';
+export const HearthBlade = {
+    [Card.HedgeKnight]: 2,
+    [Card.LoyalSquire]: 2,
+    [Card.PrincessLitha]: 1,
+    [Card.RobbinsMasterOfArms]: 1,
+    [Card.Nightguard]: 2,
+    [Card.Shadowbolt]: 2,
+    [Card.ElaraBlazingArrow]: 1,
+    [Card.WoodSlinger]: 2,
+    [Card.OzmaTheMage]: 1,
+    [Card.Armada]: 2,
+    [Card.SoulBlade]: 1,
+    [Card.CoverOfNight]: 2,
+    [Card.Sacrifice]: 1,
+    [Card.WatchTower]: 1,
+    [Card.Confluence]: 2,
+    [Card.Harvest]: 1
+};

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

@@ -0,0 +1,18 @@
+export declare const HighWave: {
+    601: number;
+    602: number;
+    603: number;
+    604: number;
+    605: number;
+    606: number;
+    607: number;
+    608: number;
+    609: number;
+    610: number;
+    611: number;
+    612: number;
+    613: number;
+    614: number;
+    615: number;
+    616: number;
+};

package/dist/material/decks/HighWave.js

@@ -0,0 +1,19 @@
+import { Card } from '../Card';
+export const HighWave = {
+    [Card.PowderMonkey]: 2,
+    [Card.AeliaSteadyHand]: 2,
+    [Card.RicoSkeye]: 1,
+    [Card.MistyGunner]: 1,
+    [Card.TropicalRuffian]: 2,
+    [Card.Scallywag]: 2,
+    [Card.OttoPouchy]: 1,
+    [Card.Skupper]: 1,
+    [Card.SaltyDog]: 2,
+    [Card.LongJawsSilver]: 1,
+    [Card.BrassDragon]: 2,
+    [Card.TreasureMap]: 1,
+    [Card.DarkBlazer]: 2,
+    [Card.BoardingParty]: 1,
+    [Card.DawnsDoom]: 2,
+    [Card.SurpriseLoot]: 1
+};

package/dist/material/decks/heathblade/ArcherRule.d.ts

@@ -0,0 +1,6 @@
+import { CardRule } from '../../CardRule';
+export declare abstract class ArcherRule extends CardRule {
+    abstract powerBonus: number;
+    getPowerIfNotStunned(): number;
+    hasElaraBlazingArrow(): boolean;
+}

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

@@ -0,0 +1,15 @@
+import { Memory } from '../../../Memory';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { CardRule } from '../../CardRule';
+import { CardTag } from '../../CardTag';
+export class ArcherRule extends CardRule {
+    getPowerIfNotStunned() {
+        if (this.remind(Memory.CurrentPlayer) === this.player || this.hasElaraBlazingArrow()) {
+            return super.getPowerIfNotStunned() + this.powerBonus;
+        }
+        return super.getPowerIfNotStunned();
+    }
+    hasElaraBlazingArrow() {
+        return new PlayerHelper(this.game, this.player).cardRules.some((rule) => rule.hasPermanentEffectOnTag(CardTag.Archer));
+    }
+}

package/dist/material/decks/heathblade/Armada.d.ts

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

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

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ArmadaRule extends CardRule {
+    challenge = true;
+    onChallengeAccepted() {
+        this.addPendingEffect();
+        return super.onChallengeAccepted();
+    }
+}
+export const Armada = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: ArmadaRule
+};

package/dist/material/decks/heathblade/ArmadaEffectRule.d.ts

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

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

@@ -0,0 +1,17 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
+export class ArmadaEffectRule extends DiscardEffectRule {
+    discardCount = Infinity;
+    getPlayerMoves() {
+        const moves = super.getPlayerMoves();
+        moves.push(this.customMove(CustomMoveType.Pass));
+        return moves;
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.Pass) {
+            return [this.customMove(CustomMoveType.Draw, { player: this.player, quantity: this.remind(Memory.EffectCount) }), ...this.endEffect()];
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/material/decks/heathblade/Confluence.d.ts

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

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

@@ -0,0 +1,19 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ConfluenceRule extends CardRule {
+    entersEffect = true;
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].type === CardType.Action) {
+            this.addPendingEffect();
+        }
+        return [];
+    }
+}
+export const Confluence = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: ConfluenceRule
+};

package/dist/material/decks/heathblade/CoverOfNight.d.ts

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

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

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

package/dist/material/decks/heathblade/CoverOfNightEffectRule.d.ts

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

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

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

package/dist/material/decks/heathblade/ElaraBlazingArrow.d.ts

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

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

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

package/dist/material/decks/heathblade/Harvest.d.ts

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

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

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

package/dist/material/decks/heathblade/HarvestEffectRule.d.ts

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

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

@@ -0,0 +1,6 @@
+import { StashPowerTokenEffectRule } from '../../../rules/StashPowerTokenEffectRule';
+export class HarvestEffectRule extends StashPowerTokenEffectRule {
+    getStashCount() {
+        return 3;
+    }
+}

package/dist/material/decks/heathblade/HedgeKnight.d.ts

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+declare class HedgeKnightRule extends CardRule {
+    getPowerIfNotStunned(): number;
+}
+export declare const HedgeKnight: {
+    power: number;
+    type: CardType;
+    tag: CardTag;
+    suit: CardSuit;
+    rule: typeof HedgeKnightRule;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
+import { CardType } from '../../CardType';
+import { Memory } from '../../../Memory';
+class HedgeKnightRule extends CardRule {
+    getPowerIfNotStunned() {
+        const wasPlayedThisTurn = this.remind(Memory.CardsPlayed, this.player).includes(this.index);
+        return super.getPowerIfNotStunned() + (wasPlayedThisTurn ? 3 : 0);
+    }
+}
+export const HedgeKnight = {
+    power: 3,
+    type: CardType.Creature,
+    tag: CardTag.Knight,
+    suit: CardSuit.Day,
+    rule: HedgeKnightRule
+};

package/dist/material/decks/heathblade/LoyalSquire.d.ts

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class LoyalSquireRule extends CardRule {
+    entersEffect: boolean;
+    onRoundEnd(): never[];
+}
+export declare const LoyalSquire: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof LoyalSquireRule;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class LoyalSquireRule extends CardRule {
+    entersEffect = true;
+    onRoundEnd() {
+        this.addPendingEffect();
+        return [];
+    }
+}
+export const LoyalSquire = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: LoyalSquireRule
+};

package/dist/material/decks/heathblade/LoyalSquireEffectRule.d.ts

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

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

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

package/dist/material/decks/heathblade/Nightguard.d.ts

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