@gamepark/skyrift 0.5.0 → 0.6.1

package/dist/material/decks/gravehurt/WitchingHour.js

@@ -5,10 +5,10 @@ import { CardType } from '../../CardType';
 import { OngoingEffectType } from '../../OngoingEffect';
 class WitchingHourRule extends CardRule {
     onEnters() {
-        this.addOngoingEffect(OngoingEffectType.PreventPlayCard);
+        this.addOngoingEffect(OngoingEffectType.PlayCardCondition);
     }
-    preventPlayCard(card) {
-        return cardProperties[card].suit === CardSuit.Twilight;
+    canPlayCard(card) {
+        return cardProperties[card].suit !== CardSuit.Twilight;
     }
 }
 export const WitchingHour = {

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

@@ -3,7 +3,7 @@ import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 declare class HedgeKnightRule extends CardRule {
-    getPowerIfNotStunned(): number;
+    onEnters(): void;
 }
 export declare const HedgeKnight: {
     power: number;

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

@@ -2,11 +2,10 @@ import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
-import { Memory } from '../../../Memory';
+import { OngoingEffectType } from '../../OngoingEffect';
 class HedgeKnightRule extends CardRule {
-    getPowerIfNotStunned() {
-        const wasPlayedThisTurn = this.remind(Memory.CardsPlayed, this.player).includes(this.index);
-        return super.getPowerIfNotStunned() + (wasPlayedThisTurn ? 3 : 0);
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PowerModifier, { value: 3, turnsLeft: 2 });
     }
 }
 export const HedgeKnight = {

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

@@ -1,6 +1,7 @@
 import { CustomMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../../CustomMoveType';
 import { EffectRule } from '../../../rules/EffectRule';
 export declare class PrincessLithaEffectRule extends EffectRule {
-    getPlayerMoves(): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChoosePlayer, number>[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
 }

package/dist/material/decks/moondragon/AkiraClearink.d.ts

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

package/dist/material/decks/moondragon/AkiraClearink.js

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

package/dist/material/decks/moondragon/AzureDragonsPeace.d.ts

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

package/dist/material/decks/moondragon/AzureDragonsPeace.js

@@ -0,0 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class AzureDragonsPeaceRule extends CardRule {
+    onEnters() {
+        const playerCreatures = this.creatures.player(this.player);
+        if (playerCreatures.length > 0) {
+            this.addPendingEffect(RuleId.AzureDragonsPeaceEffect);
+        }
+    }
+}
+export const AzureDragonsPeace = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: AzureDragonsPeaceRule
+};

package/dist/material/decks/moondragon/AzureDragonsPeaceEffectRule.d.ts

@@ -0,0 +1,10 @@
+import { CustomMove, MaterialMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../../CustomMoveType';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class AzureDragonsPeaceEffectRule extends EffectRule {
+    onRuleStart(): never[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChooseCard, number>[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    neutralize(targets: number[]): MaterialMove[];
+    onEndEffect(): MaterialMove[];
+}

package/dist/material/decks/moondragon/AzureDragonsPeaceEffectRule.js

@@ -0,0 +1,49 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { OngoingEffectType } from '../../OngoingEffect';
+export class AzureDragonsPeaceEffectRule extends EffectRule {
+    onRuleStart() {
+        this.memorize(Memory.EffectTargets, []);
+        return [];
+    }
+    getPlayerMoves() {
+        const targets = this.remind(Memory.EffectTargets);
+        if (targets.length === 0) {
+            return this.cardRule.creatures
+                .player(this.cardRule.player)
+                .getIndexes()
+                .map((index) => this.customMove(CustomMoveType.ChooseCard, index));
+        }
+        else {
+            return this.cardRule.creatures
+                .player(this.cardRule.foe)
+                .getIndexes()
+                .map((index) => this.customMove(CustomMoveType.ChooseCard, index));
+        }
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseCard) {
+            const targets = this.remind(Memory.EffectTargets);
+            if (targets.length === 0) {
+                this.memorize(Memory.EffectTargets, [move.data]);
+                if (this.cardRule.creatures.player(this.cardRule.foe).length === 0) {
+                    return this.neutralize([move.data]);
+                }
+                return [];
+            }
+            else {
+                return this.neutralize([...targets, move.data]);
+            }
+        }
+        return super.onCustomMove(move);
+    }
+    neutralize(targets) {
+        this.cardRule.addOngoingEffect(OngoingEffectType.Neutralized, { targets });
+        return this.endEffect();
+    }
+    onEndEffect() {
+        this.forget(Memory.EffectTargets);
+        return super.onEndEffect();
+    }
+}

package/dist/material/decks/moondragon/CopyPlayEffectRule.d.ts

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

package/dist/material/decks/moondragon/CopyPlayEffectRule.js

@@ -0,0 +1,33 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { MaterialType } from '../../MaterialType';
+export class CopyPlayEffectRule extends EffectRule {
+    getPlayerMoves() {
+        const moves = this.cardRule.playArea
+            .index((i) => i !== this.effectCardIndex)
+            .getIndexes()
+            .map((i) => this.customMove(CustomMoveType.ChooseCard, i));
+        moves.push(this.customMove(CustomMoveType.EndEffect));
+        return moves;
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseCard) {
+            const targetIndex = move.data;
+            const targetCard = this.game.items[MaterialType.Card][targetIndex].id.front;
+            const TargetRule = cardProperties[targetCard].rule;
+            const proxyRule = new TargetRule(this.game, this.effectCardIndex);
+            proxyRule.addPendingEffect = (ruleId) => {
+                this.memorize(Memory.PendingEffects, (effects) => [
+                    ...effects, { cardIndex: this.effectCardIndex, ruleId, sourceCard: targetCard }
+                ]);
+            };
+            const subsequentEffects = this.remind(Memory.PendingEffects).splice(1);
+            proxyRule.onEnters?.();
+            this.memorize(Memory.PendingEffects, (effects) => [...effects, ...subsequentEffects]);
+            return this.endEffect();
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/material/decks/moondragon/DartYusagi.d.ts

@@ -0,0 +1,14 @@
+import { Deck } from '../../../Deck';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class DartYusagiRule extends CardRule {
+    getPlayerPowerModifier(player: Deck): number;
+}
+export declare const DartYusagi: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DartYusagiRule;
+};
+export {};

package/dist/material/decks/moondragon/DartYusagi.js

@@ -0,0 +1,26 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { createCardRule } from '../../createCardRule';
+class DartYusagiRule extends CardRule {
+    getPlayerPowerModifier(player) {
+        const playerCreatures = this.playArea
+            .player(player)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        let modifier = 0;
+        for (const index of playerCreatures.getIndexes()) {
+            const power = createCardRule(this.game, index).getPower();
+            if (power >= 4) {
+                modifier -= power;
+            }
+        }
+        return modifier;
+    }
+}
+export const DartYusagi = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: DartYusagiRule
+};

package/dist/material/decks/moondragon/DuelOfHonor.d.ts

@@ -0,0 +1,19 @@
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PlayCardConditionEffect } from '../../EffectTraits';
+declare class DuelOfHonorRule extends CardRule implements PlayCardConditionEffect {
+    onEnters(): void;
+    canPlayCard(card: Card, player: Deck): boolean;
+    onPlayCardCondition(card: Card): void;
+    getEffectPlayers(): Deck[];
+}
+export declare const DuelOfHonor: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof DuelOfHonorRule;
+};
+export {};

package/dist/material/decks/moondragon/DuelOfHonor.js

@@ -0,0 +1,35 @@
+import { Memory } from '../../../Memory';
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class DuelOfHonorRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PlayCardCondition);
+    }
+    canPlayCard(card, player) {
+        if (cardProperties[card].type === CardType.Creature) {
+            return this.material(MaterialType.Card).location(LocationType.PlayerHand).player(player).length >= 2;
+        }
+        return true;
+    }
+    onPlayCardCondition(card) {
+        if (cardProperties[card].type === CardType.Creature) {
+            this.addPendingEffect(RuleId.DiscardEffect);
+        }
+    }
+    getEffectPlayers() {
+        const currentPlayer = this.remind(Memory.CurrentPlayer);
+        return [currentPlayer];
+    }
+}
+export const DuelOfHonor = {
+    power: 2,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: DuelOfHonorRule
+};

package/dist/material/decks/moondragon/Embush.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 { ChallengeEffect, SwitchSideEffect } from '../../EffectTraits';
+declare class EmbushRule extends CardRule implements ChallengeEffect, SwitchSideEffect {
+    onEnters(): void;
+    onChallengeAccepted(): void;
+    getSwitchSideTargets(): Material;
+}
+export declare const Embush: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof EmbushRule;
+};
+export {};

package/dist/material/decks/moondragon/Embush.js

@@ -0,0 +1,26 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { cardProperties } from '../../CardProperties';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class EmbushRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    onChallengeAccepted() {
+        this.addPendingEffect(RuleId.SwitchSideEffect);
+    }
+    getSwitchSideTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Action);
+    }
+}
+export const Embush = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: EmbushRule
+};

package/dist/material/decks/moondragon/EmbushEffectRule.d.ts

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

package/dist/material/decks/moondragon/EmbushEffectRule.js

@@ -0,0 +1,26 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class EmbushEffectRule extends EffectRule {
+    getPlayerMoves() {
+        return this.getTargets().moveItems((item) => ({
+            type: LocationType.PlayArea,
+            player: item.location.player === this.player ? this.nextPlayer : this.player,
+            id: CardType.Action
+        }));
+    }
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Action);
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/material/decks/moondragon/EmpressSama.d.ts

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

package/dist/material/decks/moondragon/EmpressSama.js

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class EmpressSamaRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.KeepActionCard);
+    }
+}
+export const EmpressSama = {
+    power: 3,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: EmpressSamaRule
+};

package/dist/material/decks/moondragon/EmpressSamaEffectRule.d.ts

@@ -0,0 +1,7 @@
+import { CustomMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleId } from '../../../rules/RuleId';
+export declare class EmpressSamaEffectRule extends PlayerTurnRule {
+    getPlayerMoves(): MaterialMove[];
+    getActionCards(): import("@gamepark/rules-api").Material<number, number, number>;
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.StartPlayerTurn>[];
+}

package/dist/material/decks/moondragon/EmpressSamaEffectRule.js

@@ -0,0 +1,29 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { CustomMoveType } from '../../../CustomMoveType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { Memory } from '../../../Memory';
+import { OngoingEffectType } from '../../OngoingEffect';
+import { RuleId } from '../../../rules/RuleId';
+export class EmpressSamaEffectRule extends PlayerTurnRule {
+    getPlayerMoves() {
+        return this.getActionCards().getIndexes()
+            .map((i) => this.customMove(CustomMoveType.ChooseCard, i));
+    }
+    getActionCards() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .player(this.player)
+            .filter((card) => cardProperties[card.id.front].type === CardType.Action);
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseCard) {
+            this.memorize(Memory.OngoingEffects, (effects) => effects.map((e) => e.type === OngoingEffectType.KeepActionCard && this.material(MaterialType.Card).getItem(e.cardIndex).location.player === this.player
+                ? { ...e, targets: [move.data] } : e));
+            return [this.startPlayerTurn(RuleId.StartPlayerTurn, this.player)];
+        }
+        return [];
+    }
+}

package/dist/material/decks/moondragon/GardenProtector.d.ts

@@ -0,0 +1,15 @@
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class GardenProtectorRule extends CardRule {
+    onCardEnters(card: Card, side: Deck): void;
+}
+export declare const GardenProtector: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof GardenProtectorRule;
+};
+export {};

package/dist/material/decks/moondragon/GardenProtector.js

@@ -0,0 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class GardenProtectorRule extends CardRule {
+    onCardEnters(card, side) {
+        if (side === this.foe && cardProperties[card].type === CardType.Creature) {
+            this.addPendingEffect(RuleId.StashPowerTokensEffect);
+        }
+    }
+}
+export const GardenProtector = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: GardenProtectorRule
+};

package/dist/material/decks/moondragon/ImperialBlade.d.ts

@@ -0,0 +1,16 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class ImperialBladeRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    getDestroyTargets(): Material;
+}
+export declare const ImperialBlade: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof ImperialBladeRule;
+};
+export {};

package/dist/material/decks/moondragon/ImperialBlade.js

@@ -0,0 +1,19 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { createCardRule } from '../../createCardRule';
+class ImperialBladeRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        return this.creatures.index((index) => createCardRule(this.game, index).getPower() >= 6);
+    }
+}
+export const ImperialBlade = {
+    power: 2,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: ImperialBladeRule
+};

package/dist/material/decks/moondragon/LotusMuse.d.ts

@@ -0,0 +1,17 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class LotusMuseRule extends CardRule {
+    get allCardsPowerTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    get allCardsStunTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    get allCardsSpecialTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    canActivate(): boolean;
+    activate(): void;
+}
+export declare const LotusMuse: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof LotusMuseRule;
+};
+export {};

package/dist/material/decks/moondragon/LotusMuse.js

@@ -0,0 +1,34 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class LotusMuseRule extends CardRule {
+    get allCardsPowerTokens() {
+        return this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens);
+    }
+    get allCardsStunTokens() {
+        return this.material(MaterialType.StunToken).location(LocationType.CardStunTokens);
+    }
+    get allCardsSpecialTokens() {
+        return this.material(MaterialType.SpecialToken).location(LocationType.CardSpecialTokens);
+    }
+    canActivate() {
+        if (!super.canActivate())
+            return false;
+        const creatureIndexes = this.creatures.getIndexes();
+        return (this.allCardsPowerTokens.getItems().some((i) => creatureIndexes.includes(i.location.parent)) ||
+            this.allCardsStunTokens.getItems().some((i) => creatureIndexes.includes(i.location.parent)) ||
+            this.allCardsSpecialTokens.getItems().some((i) => creatureIndexes.includes(i.location.parent)));
+    }
+    activate() {
+        this.addPendingEffect(RuleId.LotusMuseEffect);
+    }
+}
+export const LotusMuse = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: LotusMuseRule
+};

package/dist/material/decks/moondragon/LotusMuseEffectRule.d.ts

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

package/dist/material/decks/moondragon/LotusMuseEffectRule.js

@@ -0,0 +1,24 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class LotusMuseEffectRule extends EffectRule {
+    getPlayerMoves() {
+        const moves = [];
+        const creatures = this.cardRule.creatures.getIndexes();
+        const powerTokens = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens);
+        const stunTokens = this.material(MaterialType.StunToken).location(LocationType.CardStunTokens);
+        const specialTokens = this.material(MaterialType.SpecialToken).location(LocationType.CardSpecialTokens);
+        for (const creature of creatures) {
+            const notOnTarget = (parent) => parent !== creature;
+            moves.push(...powerTokens.parent(notOnTarget).moveItems({ type: LocationType.CardPowerTokens, parent: creature }, 1), ...stunTokens.parent(notOnTarget).moveItems({ type: LocationType.CardStunTokens, parent: creature }, 1), ...specialTokens.parent(notOnTarget).moveItems({ type: LocationType.CardSpecialTokens, parent: creature }, 1));
+        }
+        return moves;
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.PowerToken)(move) || isMoveItemType(MaterialType.StunToken)(move) || isMoveItemType(MaterialType.SpecialToken)(move)) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/material/decks/moondragon/PortalOfTheAncestors.d.ts

@@ -0,0 +1,16 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { ChallengeEffect, StashPowerTokenEffect } from '../../EffectTraits';
+declare class PortalOfTheAncestorsRule extends CardRule implements ChallengeEffect, StashPowerTokenEffect {
+    onEnters(): void;
+    onChallengeAccepted(): void;
+    getStashPowerTokenCount(): number;
+}
+export declare const PortalOfTheAncestors: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof PortalOfTheAncestorsRule;
+};
+export {};