@gamepark/skyrift 0.2.9 → 0.3.0

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()];
+    }
+}

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { ItemMove, Material } from '@gamepark/rules-api';
+import { StunCardRule } from '../../../rules/StunCardRule';
+export declare class WishLampEffectRule extends StunCardRule {
+    stunCount: number;
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+    getTargets(): Material;
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+    get catadjinnCount(): number;
+    onRuleEnd(): never[];
+}

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

@@ -0,0 +1,46 @@
+import { isCreateItemType } from '@gamepark/rules-api';
+import { Memory } from '../../../Memory';
+import { StunCardRule } from '../../../rules/StunCardRule';
+import { Card } from '../../Card';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class WishLampEffectRule extends StunCardRule {
+    stunCount = 2;
+    onRuleStart() {
+        this.memorize(Memory.EffectCount, []);
+        if (!this.getTargets().length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getTargets() {
+        const stunned = this.remind(Memory.EffectCount);
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature)
+            .index((index) => !stunned.includes(index));
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.StunToken)(move) && move.item.location.type === LocationType.CardStunTokens) {
+            const stunned = this.memorize(Memory.EffectCount, (s) => [...s, move.item.location.parent]);
+            if (stunned.length >= 1 + this.catadjinnCount || !this.getTargets().length) {
+                return this.endEffect();
+            }
+            return [];
+        }
+        return [];
+    }
+    get catadjinnCount() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .id((id) => id.front === Card.Catadjinn)
+            .length;
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

package/dist/rules/EffectRule.d.ts

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

package/dist/rules/EffectRule.js

@@ -6,9 +6,11 @@ import { Memory } from '../Memory';
 import { PlayerHelper } from './PlayerHelper';
 import { RuleId } from './RuleId';
 export class EffectRule extends PlayerTurnRule {
+    get effectCardIndex() {
+        return this.remind(Memory.PendingEffects)[0].cardIndex;
+    }
     get cardRule() {
-        const pendingEffects = this.remind(Memory.PendingEffects);
-        return new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex);
+        return new PlayerHelper(this.game, this.player).getCardRule(this.effectCardIndex);
     }
     endEffect() {
         return [this.customMove(CustomMoveType.EndEffect)];