@gamepark/skyrift 0.3.0 → 0.4.1

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

@@ -0,0 +1,25 @@
+import { Memory } from '../../../Memory';
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class AncientCurseRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    getDrawPlayer() {
+        return this.remind(Memory.ChallengeConceded) ?? this.player;
+    }
+    onChallengeAccepted() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    onChallengeDeclined() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+}
+export const AncientCurse = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: AncientCurseRule
+};

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

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

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

@@ -0,0 +1,20 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class CatadjinnRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    getPowerIfNotStunned() {
+        const nonNightCards = this.playArea.id((id) => cardProperties[id.front].suit !== CardSuit.Night);
+        return super.getPowerIfNotStunned() - nonNightCards.length;
+    }
+}
+export const Catadjinn = {
+    power: 6,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: CatadjinnRule
+};

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

@@ -0,0 +1,20 @@
+import { Material } from '@gamepark/rules-api';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect, PreventEffectsEffect } from '../../EffectTraits';
+declare class DeathTrapRule extends CardRule implements DestroyEffect, PreventEffectsEffect {
+    onEnters(): void;
+    preventEnterEffects(cardIndex: number): boolean;
+    onCardEnters(card: Card): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const DeathTrap: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DeathTrapRule;
+};
+export {};

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

@@ -0,0 +1,38 @@
+import { Memory } from '../../../Memory';
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { createCardRule } from '../../createCardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { MaterialType } from '../../MaterialType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class DeathTrapRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PreventEffects);
+    }
+    preventEnterEffects(cardIndex) {
+        return createCardRule(this.game, cardIndex).properties.type === CardType.Creature;
+    }
+    onCardEnters(card) {
+        if (cardProperties[card].type === CardType.Creature) {
+            this.removeOngoingEffect(OngoingEffectType.PreventEffects);
+            this.addPendingEffect(RuleId.DestroyEffect);
+        }
+    }
+    getDestroyTargets() {
+        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);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const DeathTrap = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: DeathTrapRule
+};

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

@@ -0,0 +1,17 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { StunEffect } from '../../EffectTraits';
+declare class DesertRaiderRule extends CardRule implements StunEffect {
+    onEnters(): void;
+    getStunTargets(): Material;
+    isAutoStun(): boolean;
+}
+export declare const DesertRaider: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DesertRaiderRule;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class DesertRaiderRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+    getStunTargets() {
+        return this.playArea.index(this.index);
+    }
+    isAutoStun() {
+        return true;
+    }
+}
+export const DesertRaider = {
+    power: 5,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: DesertRaiderRule
+};

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

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

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

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+export class DuneWardrumsRule extends CardRule {
+    getPowerIfNotStunned() {
+        return super.getPowerIfNotStunned() + this.creatures.player(this.player).length;
+    }
+}
+export const DuneWardrums = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: DuneWardrumsRule
+};

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

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

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ErgDeathslayerRule extends CardRule {
+    canBePlayed() {
+        const hasOtherCardInPlay = this.playArea.player(this.player).length > 0;
+        return !hasOtherCardInPlay && super.canBePlayed();
+    }
+}
+export const ErgDeathslayer = {
+    power: 5,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: ErgDeathslayerRule
+};

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

@@ -0,0 +1,18 @@
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PreventPlayCardEffect } from '../../EffectTraits';
+declare class MalikShadowtrackerRule extends CardRule implements PreventPlayCardEffect {
+    onEnters(): void;
+    preventPlayCard(card: Card, player: Deck): boolean;
+    onCardEnters(_card: Card, side: Deck): void;
+}
+export declare const MalikShadowtracker: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof MalikShadowtrackerRule;
+};
+export {};

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

@@ -0,0 +1,24 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class MalikShadowtrackerRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PreventPlayCard);
+    }
+    preventPlayCard(card, player) {
+        return player !== this.player && cardProperties[card].suit !== CardSuit.Twilight;
+    }
+    onCardEnters(_card, side) {
+        if (side !== this.player) {
+            this.removeOngoingEffect(OngoingEffectType.PreventPlayCard);
+        }
+    }
+}
+export const MalikShadowtracker = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: MalikShadowtrackerRule
+};

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

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

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

@@ -0,0 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class MetamorphRule extends CardRule {
+    getPowerIfNotStunned() {
+        return super.getPowerIfNotStunned() + this.creatures.player(this.player).length - 1;
+    }
+    onSkirmishWin() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+}
+export const Metamorph = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: MetamorphRule
+};

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

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

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

@@ -0,0 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class MushaFakirRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    onSkirmishLost() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+}
+export const MushaFakir = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: MushaFakirRule
+};

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { Material } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PutPowerTokenEffect, ReturnCardEffect } from '../../EffectTraits';
+declare class SandWalkersRule extends CardRule implements ReturnCardEffect, PutPowerTokenEffect {
+    onEnters(): void;
+    getPutPowerTokenTargets(): Material;
+    isAutoPutPowerToken(): boolean;
+    onCardEnters(card: Card, side: Deck): void;
+    isAutoReturn(): boolean;
+}
+export declare const SandWalkers: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof SandWalkersRule;
+};
+export {};

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

@@ -0,0 +1,30 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class SandWalkersRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.PutPowerTokensEffect);
+    }
+    getPutPowerTokenTargets() {
+        return this.creatures.player(this.player);
+    }
+    isAutoPutPowerToken() {
+        return true;
+    }
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].type === CardType.Creature) {
+            this.addPendingEffect(RuleId.ReturnCardEffect);
+        }
+    }
+    isAutoReturn() {
+        return true;
+    }
+}
+export const SandWalkers = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: SandWalkersRule
+};

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { DrawEffect } from '../../EffectTraits';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class StarlightBazaarRule extends CardRule implements DrawEffect {
+    onEnters(): void;
+    getDrawCount(): number;
+}
+export declare const StarlightBazaar: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof StarlightBazaarRule;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class StarlightBazaarRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        return 3;
+    }
+}
+export const StarlightBazaar = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: StarlightBazaarRule
+};

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

@@ -0,0 +1,18 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class VandalsRule extends CardRule implements DestroyEffect {
+    getPowerIfNotStunned(): number;
+    activate(): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const Vandals: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof VandalsRule;
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class VandalsRule extends CardRule {
+    getPowerIfNotStunned() {
+        return super.getPowerIfNotStunned() + this.creatures.player(this.player).length - 1;
+    }
+    activate() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDestroyTargets() {
+        return this.playArea.index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const Vandals = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: VandalsRule
+};

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

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

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

@@ -0,0 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class WindWrathRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.WindWrathEffect);
+    }
+}
+export const WindWrath = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: WindWrathRule
+};

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

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

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

@@ -0,0 +1,17 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { EffectRule } from '../../../rules/EffectRule';
+export class WindWrathEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = [];
+        for (const player of this.game.players) {
+            const hand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(player);
+            if (hand.length > 0) {
+                moves.push(hand.moveItemsAtOnce({ type: LocationType.PlayerDiscard, player }));
+                moves.push(this.customMove(CustomMoveType.Draw, { player, quantity: hand.length }));
+            }
+        }
+        return [...moves, ...this.endEffect()];
+    }
+}

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

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { StunEffect } from '../../EffectTraits';
+declare class WishLampRule extends CardRule implements StunEffect {
+    onEnters(): void;
+    getStunCount(): number;
+    getStunTargetsCount(): number;
+}
+export declare const WishLamp: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof WishLampRule;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { RuleId } from '../../../rules/RuleId';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class WishLampRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+    getStunCount() {
+        return 2;
+    }
+    getStunTargetsCount() {
+        return 1 + this.playArea.player(this.player).id((id) => id.front === Card.Catadjinn).length;
+    }
+}
+export const WishLamp = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: WishLampRule
+};

package/dist/rules/ChallengeEffectRule.d.ts

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

package/dist/rules/ChallengeEffectRule.js

@@ -0,0 +1,17 @@
+import { CustomMoveType } from '../CustomMoveType';
+import { EffectRule } from './EffectRule';
+import { RuleId } from './RuleId';
+export class ChallengeEffectRule extends EffectRule {
+    getPlayerMoves() {
+        return [this.customMove(CustomMoveType.Challenge), this.customMove(CustomMoveType.Pass)];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.Challenge) {
+            return [this.startPlayerTurn(RuleId.ChallengeResponse, this.nextPlayer)];
+        }
+        else if (move.type === CustomMoveType.Pass) {
+            return this.endEffect();
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/rules/ChallengeResponseRule.d.ts

@@ -0,0 +1,8 @@
+import { CustomMove, ItemMove } from '@gamepark/rules-api';
+import { ChallengeEffect } from '../material/EffectTraits';
+import { EffectRule } from './EffectRule';
+export declare class ChallengeResponseRule extends EffectRule<ChallengeEffect> {
+    getPlayerMoves(): (CustomMove | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
+}