@gamepark/skyrift 0.2.8 → 0.3.0

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

@@ -0,0 +1,24 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class CatadjinnRule extends CardRule {
+    challenge = true;
+    getPowerIfNotStunned() {
+        const nonNightCards = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => {
+            const suit = cardProperties[id.front].suit;
+            return suit === CardSuit.Twilight || suit === CardSuit.Day;
+        });
+        return Math.max(0, super.getPowerIfNotStunned() - nonNightCards.length);
+    }
+}
+export const Catadjinn = {
+    power: 6,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: CatadjinnRule
+};

package/dist/material/decks/winsands/CreatureBonusCardRule.d.ts

@@ -0,0 +1,4 @@
+import { CardRule } from '../../CardRule';
+export declare class CreatureBonusCardRule extends CardRule {
+    getPowerIfNotStunned(): number;
+}

package/dist/material/decks/winsands/CreatureBonusCardRule.js

@@ -0,0 +1,14 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class CreatureBonusCardRule extends CardRule {
+    getPowerIfNotStunned() {
+        const myCreatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        return super.getPowerIfNotStunned() + myCreatures.length - 1;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class DeathTrapRule extends CardRule {
+    onEnters(): MaterialMove[];
+}
+export declare const DeathTrap: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DeathTrapRule;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class DeathTrapRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.DeathTrap);
+        return [];
+    }
+}
+export const DeathTrap = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: DeathTrapRule
+};

package/dist/material/decks/winsands/DeathTrapEffectRule.d.ts

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

package/dist/material/decks/winsands/DeathTrapEffectRule.js

@@ -0,0 +1,18 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class DeathTrapEffectRule extends EffectRule {
+    onRuleStart() {
+        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).moveItem({
+                type: LocationType.PlayerDiscard,
+                player: currentPlayer
+            }),
+            ...this.endEffect()
+        ];
+    }
+}

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

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

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

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

package/dist/material/decks/winsands/DesertRaiderEffectRule.d.ts

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

package/dist/material/decks/winsands/DesertRaiderEffectRule.js

@@ -0,0 +1,17 @@
+import { EffectRule } from '../../../rules/EffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class DesertRaiderEffectRule extends EffectRule {
+    onRuleStart() {
+        return [
+            this.material(MaterialType.StunToken).createItem({
+                location: {
+                    type: LocationType.CardStunTokens,
+                    parent: this.effectCardIndex
+                },
+                quantity: 1
+            }),
+            ...this.endEffect()
+        ];
+    }
+}

package/dist/material/decks/winsands/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/winsands/DuneWardrums.js

@@ -0,0 +1,22 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class DuneWardrumsRule extends CardRule {
+    getPowerIfNotStunned() {
+        const myCreatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        const bonus = this.properties.type === CardType.Creature ? myCreatures.length - 1 : myCreatures.length;
+        return super.getPowerIfNotStunned() + bonus;
+    }
+}
+export const DuneWardrums = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: DuneWardrumsRule
+};

package/dist/material/decks/winsands/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/winsands/ErgDeathslayer.js

@@ -0,0 +1,19 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class ErgDeathslayerRule extends CardRule {
+    canBePlayed() {
+        const otherCardsInPlay = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player);
+        return otherCardsInPlay.length === 0 && super.canBePlayed();
+    }
+}
+export const ErgDeathslayer = {
+    power: 5,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: ErgDeathslayerRule
+};

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

@@ -0,0 +1,14 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class MalikShadowtrackerRule extends CardRule {
+    onEnters(): MaterialMove[];
+}
+export declare const MalikShadowtracker: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof MalikShadowtrackerRule;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class MalikShadowtrackerRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.ForcedSuit);
+        return [];
+    }
+}
+export const MalikShadowtracker = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: MalikShadowtrackerRule
+};

package/dist/material/decks/winsands/MalikShadowtrackerEffectRule.d.ts

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

package/dist/material/decks/winsands/MalikShadowtrackerEffectRule.js

@@ -0,0 +1,13 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { CardSuit } from '../../CardSuit';
+import { OngoingEffectType } from '../../OngoingEffect';
+export class MalikShadowtrackerEffectRule extends EffectRule {
+    onRuleStart() {
+        this.memorize(Memory.OngoingEffects, (effects) => [
+            ...effects,
+            { type: OngoingEffectType.ForcedSuit, player: this.nextPlayer, suit: CardSuit.Twilight }
+        ]);
+        return this.endEffect();
+    }
+}

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

@@ -0,0 +1,14 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DuneWardrumsRule } from './DuneWardrums';
+declare class MetamorphRule extends DuneWardrumsRule {
+    onWinRound(): MaterialMove[];
+}
+export declare const Metamorph: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof MetamorphRule;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DuneWardrumsRule } from './DuneWardrums';
+class MetamorphRule extends DuneWardrumsRule {
+    onWinRound() {
+        this.addPendingEffect();
+        return [];
+    }
+}
+export const Metamorph = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: MetamorphRule
+};

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

@@ -0,0 +1,15 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class MushaFakirRule extends CardRule {
+    entersEffect: boolean;
+    onLoseRound(): MaterialMove[];
+}
+export declare const MushaFakir: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof MushaFakirRule;
+};
+export {};

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

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

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

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

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

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

package/dist/material/decks/winsands/OasisShamanEffectRule.d.ts

@@ -0,0 +1,8 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class OasisShamanEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    get handCards(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/material/decks/winsands/OasisShamanEffectRule.js

@@ -0,0 +1,33 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class OasisShamanEffectRule extends EffectRule {
+    onRuleStart() {
+        if (!this.handCards.length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.handCards.moveItems((item) => ({
+            type: LocationType.PlayArea,
+            player: this.player,
+            id: cardProperties[item.id.front].type
+        }));
+    }
+    get handCards() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayerHand)
+            .player(this.player);
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
+            const moves = new PlayerHelper(this.game, this.player).onCardPlayed(move.itemIndex);
+            return [...moves, ...this.endEffect()];
+        }
+        return [];
+    }
+}

package/dist/material/decks/winsands/SandWalkers.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 SandWalkersRule extends CardRule {
+    entersEffect: boolean;
+    onCardEnters(card: Card, side: Deck): MaterialMove[];
+}
+export declare const SandWalkers: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof SandWalkersRule;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class SandWalkersRule extends CardRule {
+    entersEffect = true;
+    onCardEnters(card, side) {
+        if (side === this.player && cardProperties[card].type === CardType.Creature) {
+            return [
+                this.material(MaterialType.Card).index(this.index).moveItem({
+                    type: LocationType.PlayerHand,
+                    player: this.player
+                })
+            ];
+        }
+        return [];
+    }
+}
+export const SandWalkers = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: SandWalkersRule
+};

package/dist/material/decks/winsands/SandWalkersEffectRule.d.ts

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

package/dist/material/decks/winsands/SandWalkersEffectRule.js

@@ -0,0 +1,25 @@
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class SandWalkersEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = [];
+        const myCreatures = this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        for (const creatureIndex of myCreatures.getIndexes()) {
+            moves.push(this.material(MaterialType.PowerToken)
+                .location(LocationType.PowerTokenStock)
+                .createItem({
+                location: {
+                    type: LocationType.CardPowerTokens,
+                    parent: creatureIndex
+                }
+            }));
+        }
+        return [...moves, ...this.endEffect()];
+    }
+}

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

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

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

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

package/dist/material/decks/winsands/StarlightBazaarEffectRule.d.ts

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

package/dist/material/decks/winsands/StarlightBazaarEffectRule.js

@@ -0,0 +1,6 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+export class StarlightBazaarEffectRule extends DrawEffectRule {
+    getDrawCount() {
+        return 3;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DuneWardrumsRule } from './DuneWardrums';
+declare class VandalsRule extends DuneWardrumsRule {
+    oncePerTurnEffect: boolean;
+}
+export declare const Vandals: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof VandalsRule;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DuneWardrumsRule } from './DuneWardrums';
+class VandalsRule extends DuneWardrumsRule {
+    oncePerTurnEffect = true;
+}
+export const Vandals = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: VandalsRule
+};

package/dist/material/decks/winsands/VandalsEffectRule.d.ts

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

package/dist/material/decks/winsands/VandalsEffectRule.js

@@ -0,0 +1,14 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class VandalsEffectRule extends DrawEffectRule {
+    onRuleStart() {
+        return [
+            this.material(MaterialType.Card).index(this.effectCardIndex).moveItem({
+                type: LocationType.PlayerDiscard,
+                player: this.player
+            }),
+            ...super.onRuleStart()
+        ];
+    }
+}

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

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

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

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

package/dist/material/decks/winsands/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/winsands/WindWrathEffectRule.js

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