@gamepark/skyrift 0.1.0

package/dist/material/decks/highwave/TropicalRuffian.js

@@ -0,0 +1,12 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class TropicalRuffianRule extends CardRule {
+    entersEffect = true;
+}
+export const TropicalRuffian = {
+    power: 5,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: TropicalRuffianRule
+};

package/dist/rules/ChallengeRule.d.ts

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

package/dist/rules/ChallengeRule.js

@@ -0,0 +1,23 @@
+import { isCreateItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+import { PlayerHelper } from './PlayerHelper';
+export class ChallengeRule extends EffectRule {
+    getPlayerMoves() {
+        return [this.material(MaterialType.Crystal).createItem({ location: { type: LocationType.Stake } }), this.customMove(CustomMoveType.ConcedeRound)];
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.Crystal)(move) && move.item.location.type === LocationType.Stake) {
+            return new PlayerHelper(this.game).getPendingEffectCardRule().onChallengeAccepted();
+        }
+        return [];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ConcedeRound) {
+            return new PlayerHelper(this.game).getPendingEffectCardRule().onChallengeDeclined();
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/rules/DestroyEffectRule.d.ts

@@ -0,0 +1,8 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from './EffectRule';
+export declare abstract class DestroyEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    abstract getTargets(): Material;
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/rules/DestroyEffectRule.js

@@ -0,0 +1,21 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class DestroyEffectRule extends EffectRule {
+    onRuleStart() {
+        if (!this.getTargets().length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.getTargets().moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.location.player }));
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/rules/DiscardEffectRule.d.ts

@@ -0,0 +1,10 @@
+import { ItemMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { EffectRule } from './EffectRule';
+export declare class DiscardEffectRule extends EffectRule {
+    discardCount: number;
+    onRuleStart(): never[];
+    getPlayerMoves(): MaterialMove[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+    onDiscard(_move: MoveItem): MaterialMove[];
+    onRuleEnd(): never[];
+}

package/dist/rules/DiscardEffectRule.js

@@ -0,0 +1,35 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { EffectRule } from './EffectRule';
+export class DiscardEffectRule extends EffectRule {
+    discardCount = 1;
+    onRuleStart() {
+        this.memorize(Memory.EffectCount, 0);
+        return [];
+    }
+    getPlayerMoves() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerHand)
+            .player(this.player)
+            .moveItems({ type: LocationType.PlayerDiscard, player: this.player });
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
+            return this.onDiscard(move);
+        }
+        return [];
+    }
+    onDiscard(_move) {
+        const count = this.memorize(Memory.EffectCount, (count) => count + 1);
+        if (count >= this.discardCount) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

package/dist/rules/DrawEffectRule.d.ts

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

package/dist/rules/DrawEffectRule.js

@@ -0,0 +1,15 @@
+import { CustomMoveType } from '../CustomMoveType';
+import { EffectRule } from './EffectRule';
+export class DrawEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = this.endEffect();
+        const drawCount = this.getDrawCount();
+        if (drawCount > 0) {
+            moves.unshift(this.customMove(CustomMoveType.Draw, { player: this.player, quantity: drawCount }));
+        }
+        return moves;
+    }
+    getDrawCount() {
+        return 1;
+    }
+}

package/dist/rules/EffectRule.d.ts

@@ -0,0 +1,7 @@
+import { CustomMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+export declare class EffectRule extends PlayerTurnRule {
+    get cardRule(): import("../material/CardRule").CardRule;
+    endEffect(): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    onEndEffect(): MaterialMove[];
+}

package/dist/rules/EffectRule.js

@@ -0,0 +1,41 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { PlayerHelper } from './PlayerHelper';
+import { RuleId } from './RuleId';
+export class EffectRule extends PlayerTurnRule {
+    get cardRule() {
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        return new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex);
+    }
+    endEffect() {
+        return [this.customMove(CustomMoveType.EndEffect)];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.EndEffect) {
+            return this.onEndEffect();
+        }
+        return [];
+    }
+    onEndEffect() {
+        this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        if (pendingEffects.length > 0) {
+            return new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex).startEffect();
+        }
+        const crystalsInStake = this.material(MaterialType.Crystal).location(LocationType.Stake).getQuantity();
+        if (crystalsInStake === 0) {
+            return [this.startRule(RuleId.PrepareNextRound)];
+        }
+        const currentPlayer = this.remind(Memory.CurrentPlayer);
+        const playerHelper = new PlayerHelper(this.game, currentPlayer);
+        if (this.remind(Memory.CardsPlayed, currentPlayer).length && playerHelper.hasMorePower()) {
+            return [this.startPlayerTurn(RuleId.StartPlayerTurn, playerHelper.foe)];
+        }
+        else {
+            return [this.startPlayerTurn(RuleId.PlayCard, this.remind(Memory.CurrentPlayer))];
+        }
+    }
+}

package/dist/rules/EndRoundRule.d.ts

@@ -0,0 +1,4 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+export declare class EndRoundRule extends PlayerTurnRule {
+    onRuleStart(): (import("@gamepark/rules-api").EndGame | import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").SetTutorialStep | import("@gamepark/rules-api").CloseTutorialPopup | import("@gamepark/rules-api").ChangeView<number> | import("@gamepark/rules-api").CreateItem<number, number, number> | import("@gamepark/rules-api").CreateItemsAtOnce<number, number, number> | import("@gamepark/rules-api").DeleteItem<number> | import("@gamepark/rules-api").DeleteItemsAtOnce<number> | import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").MoveItemsAtOnce<number, number, number> | import("@gamepark/rules-api").Shuffle<number> | import("@gamepark/rules-api").RollItem<number, number, number> | import("@gamepark/rules-api").SelectItem<number> | import("@gamepark/rules-api").StartPlayerTurn<number, number> | import("@gamepark/rules-api").StartSimultaneousRule<number, number> | import("@gamepark/rules-api").StartRule<number> | import("@gamepark/rules-api").EndPlayerTurn<number> | import("@gamepark/rules-api").DisplayHelp<number, number, number, number> | import("@gamepark/rules-api").DropItem<number>)[];
+}

package/dist/rules/EndRoundRule.js

@@ -0,0 +1,47 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { PlayerHelper } from './PlayerHelper';
+import { RuleId } from './RuleId';
+export class EndRoundRule extends PlayerTurnRule {
+    onRuleStart() {
+        const winner = this.nextPlayer;
+        const loser = this.player;
+        const moves = [];
+        this.memorize(Memory.NextRoundStartPlayer, loser);
+        const stake = this.material(MaterialType.Crystal).location(LocationType.Stake);
+        if (stake.getQuantity())
+            moves.push(stake.moveItem({ type: LocationType.PlayerCrystals, player: winner }, stake.getQuantity()));
+        const loserCards = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(loser)
+            .sort((item) => item.location.x)
+            .getIndexes();
+        const winnerCards = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(winner)
+            .sort((item) => item.location.x)
+            .getIndexes();
+        for (const cardIndex of loserCards) {
+            const cardRule = new PlayerHelper(this.game, loser).getCardRule(cardIndex);
+            if (!cardRule.isStunned()) {
+                moves.push(...cardRule.onRoundEnd(false));
+            }
+        }
+        for (const cardIndex of winnerCards) {
+            const cardRule = new PlayerHelper(this.game, winner).getCardRule(cardIndex);
+            if (!cardRule.isStunned()) {
+                moves.push(...cardRule.onRoundEnd(true));
+            }
+        }
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        if (pendingEffects.length === 0) {
+            moves.push(this.startRule(RuleId.PrepareNextRound));
+        }
+        else {
+            moves.push(...new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex).startEffect());
+        }
+        return moves;
+    }
+}

package/dist/rules/GainCrystalEffectRule.d.ts

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

package/dist/rules/GainCrystalEffectRule.js

@@ -0,0 +1,8 @@
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class GainCrystalEffectRule extends EffectRule {
+    onRuleStart() {
+        return [this.material(MaterialType.Crystal).createItem({ location: { type: LocationType.PlayerCrystals, player: this.player } }), ...this.endEffect()];
+    }
+}

package/dist/rules/MayChallengeRule.d.ts

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

package/dist/rules/MayChallengeRule.js

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

package/dist/rules/PlayCardRule.d.ts

@@ -0,0 +1,9 @@
+import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+export declare class PlayCardRule extends PlayerTurnRule {
+    onRuleStart(): never[];
+    getPlayerMoves(): MaterialMove[];
+    get cardsICanPlay(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    private hasMorePower;
+}

package/dist/rules/PlayCardRule.js

@@ -0,0 +1,92 @@
+import { isMoveItemType, PlayerTurnRule } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { cardProperties } from '../material/CardProperties';
+import { CardSuit } from '../material/CardSuit';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { PlayerHelper } from './PlayerHelper';
+import { RuleId } from './RuleId';
+export class PlayCardRule extends PlayerTurnRule {
+    onRuleStart() {
+        return [];
+    }
+    getPlayerMoves() {
+        const moves = this.cardsICanPlay.moveItems((item) => ({
+            type: LocationType.PlayArea,
+            player: this.player,
+            id: cardProperties[item.id.front].type
+        }));
+        moves.push(this.customMove(CustomMoveType.ConcedeRound));
+        const playerHelper = new PlayerHelper(this.game);
+        const powerTokensStash = this.material(MaterialType.PowerToken).location(LocationType.PlayerStash).player(this.player);
+        if (powerTokensStash.getQuantity()) {
+            for (const index of playerHelper.cardsInPlay.getIndexes()) {
+                moves.push(powerTokensStash.moveItem({ type: LocationType.CardPowerTokens, parent: index }, 1));
+            }
+        }
+        const usedEffects = this.remind(Memory.OncePerTurnEffects);
+        for (const cardRule of playerHelper.cardRules) {
+            if (cardRule.oncePerTurnEffect && !cardRule.isStunned() && !usedEffects.some((effect) => effect.cardIndex === cardRule.index)) {
+                moves.push(this.customMove(CustomMoveType.ActivateCard, cardRule.index));
+            }
+        }
+        return moves;
+    }
+    get cardsICanPlay() {
+        const playerHelper = new PlayerHelper(this.game);
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerHand)
+            .player(this.player)
+            .index((index) => playerHelper.getCardRule(index).canBePlayed());
+    }
+    afterItemMove(move) {
+        const moves = [];
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
+            this.memorize(Memory.CardsPlayed, (cards) => [...cards, move.itemIndex], this.player);
+            const cardRule = new PlayerHelper(this.game, this.player).getCardRule(move.itemIndex);
+            if (!this.remind(Memory.Suit)) {
+                const card = this.material(MaterialType.Card).getItem(move.itemIndex);
+                const suit = cardProperties[card.id.front].suit;
+                if (suit === CardSuit.Day || suit === CardSuit.Night) {
+                    this.memorize(Memory.Suit, suit);
+                }
+            }
+            const cardsInPlay = this.material(MaterialType.Card).location(LocationType.PlayArea);
+            for (const cardIndex of cardsInPlay.getIndexes()) {
+                if (cardIndex !== move.itemIndex) {
+                    const otherCardRule = new PlayerHelper(this.game, this.player).getCardRule(cardIndex);
+                    if (!otherCardRule.isStunned()) {
+                        moves.push(...otherCardRule.onCardEnters(cardRule.card, move.location.player));
+                    }
+                }
+            }
+            moves.push(...cardRule.onEnters());
+            const pendingEffects = this.remind(Memory.PendingEffects);
+            if (pendingEffects.length > 0) {
+                return new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex).startEffect();
+            }
+        }
+        if (isMoveItemType(MaterialType.Card)(move) || isMoveItemType(MaterialType.PowerToken)(move)) {
+            if (this.remind(Memory.CardsPlayed, this.player).length > 0 && this.hasMorePower()) {
+                moves.push(this.startPlayerTurn(RuleId.StartPlayerTurn, this.nextPlayer));
+            }
+        }
+        return moves;
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ConcedeRound) {
+            return [this.startRule(RuleId.EndRound)];
+        }
+        else if (move.type === CustomMoveType.ActivateCard) {
+            const cardIndex = move.data;
+            const cardRule = new PlayerHelper(this.game, this.player).getCardRule(cardIndex);
+            this.memorize(Memory.OncePerTurnEffects, (effects) => [...effects, { cardIndex }]);
+            return cardRule.startEffect();
+        }
+        return [];
+    }
+    hasMorePower() {
+        return new PlayerHelper(this.game, this.player).getPower() > new PlayerHelper(this.game, this.nextPlayer).getPower();
+    }
+}

package/dist/rules/PlayerHelper.d.ts

@@ -0,0 +1,13 @@
+import { MaterialGame, MaterialRulesPart } from '@gamepark/rules-api';
+import { Deck } from '../Deck';
+export declare class PlayerHelper extends MaterialRulesPart {
+    private player;
+    constructor(game: MaterialGame, player?: Deck);
+    getCardRule(cardIndex: number, card?: import("../material/Card").Card): import("../material/CardRule").CardRule;
+    getPendingEffectCardRule(): import("../material/CardRule").CardRule;
+    get cardsInPlay(): import("@gamepark/rules-api").Material<number, number, number>;
+    get cardRules(): import("../material/CardRule").CardRule[];
+    getPower(): number;
+    get foe(): number;
+    hasMorePower(): boolean;
+}

package/dist/rules/PlayerHelper.js

@@ -0,0 +1,36 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { sumBy } from 'es-toolkit';
+import { cardProperties } from '../material/CardProperties';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+export class PlayerHelper extends MaterialRulesPart {
+    player;
+    constructor(game, player = game.rule.player) {
+        super(game);
+        this.player = player;
+    }
+    getCardRule(cardIndex, card = this.material(MaterialType.Card).getItem(cardIndex).id.front) {
+        const Rule = cardProperties[card].rule;
+        return new Rule(this.game, cardIndex);
+    }
+    getPendingEffectCardRule() {
+        const cardIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
+        return this.getCardRule(cardIndex);
+    }
+    get cardsInPlay() {
+        return this.material(MaterialType.Card).location(LocationType.PlayArea).player(this.player);
+    }
+    get cardRules() {
+        return this.cardsInPlay.getIndexes().map((index) => this.getCardRule(index));
+    }
+    getPower() {
+        return sumBy(this.cardRules, (rule) => rule.getPower());
+    }
+    get foe() {
+        return this.game.players.find((p) => p !== this.player);
+    }
+    hasMorePower() {
+        return this.getPower() > new PlayerHelper(this.game, this.foe).getPower();
+    }
+}

package/dist/rules/PrepareNextRoundRule.d.ts

@@ -0,0 +1,7 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { Deck } from '../Deck';
+import { RuleId } from './RuleId';
+export declare class PrepareNextRoundRule extends MaterialRulesPart {
+    onRuleStart(): (import("@gamepark/rules-api").CustomMove | import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").StartPlayerTurn<Deck, RuleId.StartRound>)[];
+    onRuleEnd(): never[];
+}

package/dist/rules/PrepareNextRoundRule.js

@@ -0,0 +1,24 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { RuleId } from './RuleId';
+export class PrepareNextRoundRule extends MaterialRulesPart {
+    onRuleStart() {
+        const nextRoundStartPlayer = this.remind(Memory.NextRoundStartPlayer);
+        const moves = [];
+        moves.push(...this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.location.player })));
+        moves.push(this.customMove(CustomMoveType.Draw, { player: nextRoundStartPlayer, quantity: 3 }));
+        const otherPlayer = this.game.players.find((p) => p !== nextRoundStartPlayer);
+        moves.push(this.customMove(CustomMoveType.Draw, { player: otherPlayer, quantity: 3 }));
+        moves.push(this.startPlayerTurn(RuleId.StartRound, nextRoundStartPlayer));
+        return moves;
+    }
+    onRuleEnd() {
+        this.forget(Memory.NextRoundStartPlayer);
+        return [];
+    }
+}

package/dist/rules/PutPowerTokenEffectRule.d.ts

@@ -0,0 +1,8 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from './EffectRule';
+export declare abstract class PutPowerTokenEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    abstract getTargets(): Material;
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/rules/PutPowerTokenEffectRule.js

@@ -0,0 +1,24 @@
+import { isCreateItemType } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class PutPowerTokenEffectRule extends EffectRule {
+    onRuleStart() {
+        if (!this.getTargets().length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        const powerTokens = this.material(MaterialType.PowerToken);
+        return this.getTargets()
+            .getIndexes()
+            .map((index) => powerTokens.createItem({ location: { type: LocationType.CardPowerTokens, parent: index } }));
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.PowerToken)(move) && move.item.location.type === LocationType.CardPowerTokens) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/rules/ReturnCardRule.d.ts

@@ -0,0 +1,9 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from './EffectRule';
+export declare abstract class ReturnCardRule extends EffectRule {
+    isOptional: boolean;
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    abstract getTargets(): Material;
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/rules/ReturnCardRule.js

@@ -0,0 +1,27 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class ReturnCardRule extends EffectRule {
+    isOptional = true;
+    onRuleStart() {
+        if (!this.getTargets().length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        const moves = this.getTargets().moveItems({ type: LocationType.PlayerHand, player: this.player });
+        if (this.isOptional) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerHand) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/rules/RuleId.d.ts

@@ -0,0 +1,34 @@
+export declare enum RuleId {
+    StartRound = 1,
+    StartPlayerTurn = 2,
+    PlayCard = 3,
+    EndRound = 4,
+    PrepareNextRound = 5,
+    MayChallenge = 6,
+    Challenge = 7,
+    LoyalSquireEffect = 102,
+    PrincessLithaEffect = 103,
+    RobbinsMasterOfArmsEffect = 104,
+    OzmaTheMageEffect = 109,
+    ArmadaEffect = 110,
+    SoulBladeEffect = 111,
+    CoverOfNightEffect = 112,
+    SacrificeEffect = 113,
+    WatchTowerEffect = 114,
+    ConfluenceEffect = 115,
+    HarvestEffect = 116,
+    PowderMonkeyEffect = 601,
+    AeliaSteadyHandEffect = 602,
+    RicoSkeyeEffect = 603,
+    TropicalRuffianEffect = 605,
+    ScallywagEffect = 606,
+    OttoPouchyEffect = 607,
+    SkupperEffect = 608,
+    SaltyDogEffect = 609,
+    LongJawsSilverEffect = 610,
+    TreasureMapEffect = 612,
+    DarkBlazerEffect = 613,
+    BoardingPartyEffect = 614,
+    DawnsDoomEffect = 615,
+    SurpriseLootEffect = 616
+}

package/dist/rules/RuleId.js

@@ -0,0 +1,36 @@
+import { Card } from '../material/Card';
+export var RuleId;
+(function (RuleId) {
+    RuleId[RuleId["StartRound"] = 1] = "StartRound";
+    RuleId[RuleId["StartPlayerTurn"] = 2] = "StartPlayerTurn";
+    RuleId[RuleId["PlayCard"] = 3] = "PlayCard";
+    RuleId[RuleId["EndRound"] = 4] = "EndRound";
+    RuleId[RuleId["PrepareNextRound"] = 5] = "PrepareNextRound";
+    RuleId[RuleId["MayChallenge"] = 6] = "MayChallenge";
+    RuleId[RuleId["Challenge"] = 7] = "Challenge";
+    RuleId[RuleId["LoyalSquireEffect"] = 102] = "LoyalSquireEffect";
+    RuleId[RuleId["PrincessLithaEffect"] = 103] = "PrincessLithaEffect";
+    RuleId[RuleId["RobbinsMasterOfArmsEffect"] = 104] = "RobbinsMasterOfArmsEffect";
+    RuleId[RuleId["OzmaTheMageEffect"] = 109] = "OzmaTheMageEffect";
+    RuleId[RuleId["ArmadaEffect"] = 110] = "ArmadaEffect";
+    RuleId[RuleId["SoulBladeEffect"] = 111] = "SoulBladeEffect";
+    RuleId[RuleId["CoverOfNightEffect"] = 112] = "CoverOfNightEffect";
+    RuleId[RuleId["SacrificeEffect"] = 113] = "SacrificeEffect";
+    RuleId[RuleId["WatchTowerEffect"] = 114] = "WatchTowerEffect";
+    RuleId[RuleId["ConfluenceEffect"] = 115] = "ConfluenceEffect";
+    RuleId[RuleId["HarvestEffect"] = 116] = "HarvestEffect";
+    RuleId[RuleId["PowderMonkeyEffect"] = 601] = "PowderMonkeyEffect";
+    RuleId[RuleId["AeliaSteadyHandEffect"] = 602] = "AeliaSteadyHandEffect";
+    RuleId[RuleId["RicoSkeyeEffect"] = 603] = "RicoSkeyeEffect";
+    RuleId[RuleId["TropicalRuffianEffect"] = 605] = "TropicalRuffianEffect";
+    RuleId[RuleId["ScallywagEffect"] = 606] = "ScallywagEffect";
+    RuleId[RuleId["OttoPouchyEffect"] = 607] = "OttoPouchyEffect";
+    RuleId[RuleId["SkupperEffect"] = 608] = "SkupperEffect";
+    RuleId[RuleId["SaltyDogEffect"] = 609] = "SaltyDogEffect";
+    RuleId[RuleId["LongJawsSilverEffect"] = 610] = "LongJawsSilverEffect";
+    RuleId[RuleId["TreasureMapEffect"] = 612] = "TreasureMapEffect";
+    RuleId[RuleId["DarkBlazerEffect"] = 613] = "DarkBlazerEffect";
+    RuleId[RuleId["BoardingPartyEffect"] = 614] = "BoardingPartyEffect";
+    RuleId[RuleId["DawnsDoomEffect"] = 615] = "DawnsDoomEffect";
+    RuleId[RuleId["SurpriseLootEffect"] = 616] = "SurpriseLootEffect";
+})(RuleId || (RuleId = {}));

package/dist/rules/StartPlayerTurnRule.d.ts

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