@gamepark/skyrift 0.2.9 → 0.4.0

package/dist/material/decks/gravehurt/WitchingHour.d.ts

@@ -0,0 +1,16 @@
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PreventPlayCardEffect } from '../../EffectTraits';
+declare class WitchingHourRule extends CardRule implements PreventPlayCardEffect {
+    onEnters(): void;
+    preventPlayCard(card: Card): boolean;
+}
+export declare const WitchingHour: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof WitchingHourRule;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class WitchingHourRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PreventPlayCard);
+    }
+    preventPlayCard(card) {
+        return cardProperties[card].suit === CardSuit.Twilight;
+    }
+}
+export const WitchingHour = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: WitchingHourRule
+};

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

@@ -1,7 +1,7 @@
 import { Memory } from '../../../Memory';
 import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { Card } from '../../Card';
 import { CardRule } from '../../CardRule';
-import { CardTag } from '../../CardTag';
 export class ArcherRule extends CardRule {
     getPowerIfNotStunned() {
         if (this.remind(Memory.CurrentPlayer) === this.player || this.hasElaraBlazingArrow()) {
@@ -10,6 +10,6 @@ export class ArcherRule extends CardRule {
         return super.getPowerIfNotStunned();
     }
     hasElaraBlazingArrow() {
-        return new PlayerHelper(this.game, this.player).cardRules.some((rule) => rule.hasPermanentEffectOnTag(CardTag.Archer));
+        return new PlayerHelper(this.game, this.player).hasCard(Card.ElaraBlazingArrow);
     }
 }

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

@@ -1,9 +1,10 @@
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class ArmadaRule extends CardRule {
-    challenge: boolean;
-    onChallengeAccepted(): import("@gamepark/rules-api").CustomMove[];
+import { ChallengeEffect } from '../../EffectTraits';
+declare class ArmadaRule extends CardRule implements ChallengeEffect {
+    onEnters(): void;
+    onChallengeAccepted(): void;
 }
 export declare const Armada: {
     power: number;

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

@@ -1,11 +1,13 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class ArmadaRule extends CardRule {
-    challenge = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
     onChallengeAccepted() {
-        this.addPendingEffect();
-        return super.onChallengeAccepted();
+        this.addPendingEffect(RuleId.ArmadaEffect);
     }
 }
 export const Armada = {

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

@@ -1,7 +1,7 @@
 import { CustomMove } from '@gamepark/rules-api';
 import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
 export declare class ArmadaEffectRule extends DiscardEffectRule {
-    discardCount: number;
     getPlayerMoves(): import("@gamepark/rules-api").MaterialMove[];
+    onDiscard(): never[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
 }

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

@@ -2,12 +2,15 @@ import { CustomMoveType } from '../../../CustomMoveType';
 import { Memory } from '../../../Memory';
 import { DiscardEffectRule } from '../../../rules/DiscardEffectRule';
 export class ArmadaEffectRule extends DiscardEffectRule {
-    discardCount = Infinity;
     getPlayerMoves() {
         const moves = super.getPlayerMoves();
         moves.push(this.customMove(CustomMoveType.Pass));
         return moves;
     }
+    onDiscard() {
+        this.memorize(Memory.EffectCount, (count) => count + 1);
+        return [];
+    }
     onCustomMove(move) {
         if (move.type === CustomMoveType.Pass) {
             return [this.customMove(CustomMoveType.Draw, { player: this.player, quantity: this.remind(Memory.EffectCount) }), ...this.endEffect()];

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

@@ -1,12 +1,11 @@
-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 ConfluenceRule extends CardRule {
-    entersEffect: boolean;
-    onCardEnters(card: Card, side: Deck): MaterialMove[];
+    onEnters(): void;
+    onCardEnters(card: Card, side: Deck): void;
 }
 export declare const Confluence: {
     power: number;

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

@@ -1,14 +1,16 @@
+import { RuleId } from '../../../rules/RuleId';
 import { cardProperties } from '../../CardProperties';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class ConfluenceRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
     onCardEnters(card, side) {
         if (side === this.player && cardProperties[card].type === CardType.Action) {
-            this.addPendingEffect();
+            this.addPendingEffect(RuleId.DrawEffect);
         }
-        return [];
     }
 }
 export const Confluence = {

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

@@ -1,8 +1,10 @@
 import { CardRule } from '../../CardRule';
+import { StunEffect } from '../../EffectTraits';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class CoverOfNightRule extends CardRule {
-    entersEffect: boolean;
+declare class CoverOfNightRule extends CardRule implements StunEffect {
+    onEnters(): void;
+    getStunCount(): number;
 }
 export declare const CoverOfNight: {
     power: number;

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

@@ -1,8 +1,14 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class CoverOfNightRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.StunEffect);
+    }
+    getStunCount() {
+        return 2;
+    }
 }
 export const CoverOfNight = {
     power: 2,

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

@@ -1,8 +1,10 @@
 import { CardRule } from '../../CardRule';
+import { StashPowerTokenEffect } from '../../EffectTraits';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class HarvestRule extends CardRule {
-    entersEffect: boolean;
+declare class HarvestRule extends CardRule implements StashPowerTokenEffect {
+    onEnters(): void;
+    getStashPowerTokenCount(): number;
 }
 export declare const Harvest: {
     power: number;

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

@@ -1,8 +1,14 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class HarvestRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.StashPowerTokensEffect);
+    }
+    getStashPowerTokenCount() {
+        return 3;
+    }
 }
 export const Harvest = {
     power: 2,

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

@@ -1,9 +1,12 @@
+import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class LoyalSquireRule extends CardRule {
-    entersEffect: boolean;
-    onRoundEnd(): never[];
+import { ReturnCardEffect } from '../../EffectTraits';
+declare class LoyalSquireRule extends CardRule implements ReturnCardEffect {
+    onEnters(): void;
+    onSkirmishEnd(): void;
+    getReturnTargets(): Material;
 }
 export declare const LoyalSquire: {
     power: number;

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

@@ -1,11 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
+import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 class LoyalSquireRule extends CardRule {
-    entersEffect = true;
-    onRoundEnd() {
-        this.addPendingEffect();
-        return [];
+    onEnters() {
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+    }
+    onSkirmishEnd() {
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+    }
+    getReturnTargets() {
+        return this.playArea.id((id) => cardProperties[id.front].tag === CardTag.Knight);
     }
 }
 export const LoyalSquire = {

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

@@ -1,17 +1,11 @@
-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 NightguardRule extends CardRule {
     getPowerIfNotStunned() {
-        const creatures = this.material(MaterialType.Card)
-            .location(LocationType.PlayArea)
-            .id((id) => cardProperties[id.front].type === CardType.Creature);
-        const myCreatures = creatures.player(this.player).length;
-        const opponentCreatures = creatures.player((p) => p !== this.player).length;
-        return super.getPowerIfNotStunned() + (opponentCreatures > myCreatures ? 3 : 0);
+        const myCreatures = this.creatures.player(this.player).length;
+        const foeCreatures = this.creatures.player(this.foe).length;
+        return super.getPowerIfNotStunned() + (foeCreatures > myCreatures ? 3 : 0);
     }
 }
 export const Nightguard = {

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

@@ -1,12 +1,14 @@
-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 OzmaTheMageRule extends CardRule {
-    onCardEnters(card: Card, side: Deck): MaterialMove[];
-    onLeave(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+import { PutPowerTokenEffect } from '../../EffectTraits';
+declare class OzmaTheMageRule extends CardRule implements PutPowerTokenEffect {
+    onCardEnters(card: Card, side: Deck): void;
+    isAutoPutPowerToken(): boolean;
+    onLeaves(): import("@gamepark/rules-api").MaterialMove[];
+    stashPowerTokens(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
 }
 export declare const OzmaTheMage: {
     power: number;

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

@@ -1,3 +1,4 @@
+import { RuleId } from '../../../rules/RuleId';
 import { cardProperties } from '../../CardProperties';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
@@ -7,11 +8,16 @@ import { MaterialType } from '../../MaterialType';
 class OzmaTheMageRule extends CardRule {
     onCardEnters(card, side) {
         if (side === this.player && cardProperties[card].type === CardType.Action) {
-            this.addPendingEffect();
+            this.addPendingEffect(RuleId.PutPowerTokensEffect);
         }
-        return [];
     }
-    onLeave() {
+    isAutoPutPowerToken() {
+        return true;
+    }
+    onLeaves() {
+        return [...this.stashPowerTokens(), ...this.removeStunTokens(), ...this.removeSpecialTokens()];
+    }
+    stashPowerTokens() {
         const powerTokens = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index);
         return powerTokens.moveItems({ type: LocationType.PlayerStash, player: this.player }, powerTokens.getQuantity());
     }

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

@@ -1,17 +1,15 @@
 import { EffectRule } from '../../../rules/EffectRule';
-import { Memory } from '../../../Memory';
 import { LocationType } from '../../LocationType';
 import { MaterialType } from '../../MaterialType';
 export class OzmaTheMageEffectRule extends EffectRule {
     onRuleStart() {
-        const ozmaIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
         return [
             this.material(MaterialType.PowerToken)
                 .location(LocationType.PowerTokenStock)
                 .createItem({
                 location: {
                     type: LocationType.CardPowerTokens,
-                    parent: ozmaIndex
+                    parent: this.effectCardIndex
                 }
             }),
             ...this.endEffect()

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

@@ -1,11 +1,10 @@
-import { MaterialMove } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 declare class PrincessLithaRule extends CardRule {
     getPowerIfNotStunned(): number;
-    onWinRound(): MaterialMove[];
+    onSkirmishWin(): void;
 }
 export declare const PrincessLitha: {
     power: number;

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

@@ -1,22 +1,15 @@
-import { cardProperties } from '../../CardProperties';
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
-import { LocationType } from '../../LocationType';
-import { MaterialType } from '../../MaterialType';
 class PrincessLithaRule extends CardRule {
     getPowerIfNotStunned() {
-        const otherCreaturesCount = this.material(MaterialType.Card)
-            .location(LocationType.PlayArea)
-            .player(this.player)
-            .id((id) => cardProperties[id.front].type === CardType.Creature)
-            .length - 1;
+        const otherCreaturesCount = this.creatures.player(this.player).length - 1;
         return super.getPowerIfNotStunned() + otherCreaturesCount;
     }
-    onWinRound() {
-        this.addPendingEffect();
-        return [];
+    onSkirmishWin() {
+        this.addPendingEffect(RuleId.PrincessLithaEffect);
     }
 }
 export const PrincessLitha = {

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

@@ -1,9 +1,13 @@
+import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
-declare class RobbinsMasterOfArmsRule extends CardRule {
-    entersEffect: boolean;
+import { PutPowerTokenEffect } from '../../EffectTraits';
+declare class RobbinsMasterOfArmsRule extends CardRule implements PutPowerTokenEffect {
+    onEnters(): void;
+    isAutoPutPowerToken(): boolean;
+    getPutPowerTokenTargets(): Material;
 }
 export declare const RobbinsMasterOfArms: {
     power: number;

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

@@ -1,9 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 class RobbinsMasterOfArmsRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.PutPowerTokensEffect);
+    }
+    isAutoPutPowerToken() {
+        return true;
+    }
+    getPutPowerTokenTargets() {
+        return this.creatures.player(this.player).index((index) => index !== this.index);
+    }
 }
 export const RobbinsMasterOfArms = {
     power: 3,

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

@@ -1,4 +1,3 @@
-import { Memory } from '../../../Memory';
 import { cardProperties } from '../../CardProperties';
 import { CardType } from '../../CardType';
 import { LocationType } from '../../LocationType';
@@ -7,13 +6,12 @@ import { EffectRule } from '../../../rules/EffectRule';
 export class RobbinsMasterOfArmsEffectRule extends EffectRule {
     onRuleStart() {
         const moves = [];
-        const robbinsIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
         const otherCreatures = this.material(MaterialType.Card)
             .location(LocationType.PlayArea)
             .player(this.player)
             .id((id) => cardProperties[id.front].type === CardType.Creature)
             .getIndexes()
-            .filter(index => index !== robbinsIndex);
+            .filter(index => index !== this.effectCardIndex);
         for (const creatureIndex of otherCreatures) {
             moves.push(this.material(MaterialType.PowerToken)
                 .location(LocationType.PowerTokenStock)

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

@@ -1,8 +1,13 @@
+import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class SacrificeRule extends CardRule {
-    entersEffect: boolean;
+import { DestroyEffect } from '../../EffectTraits';
+declare class SacrificeRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    getDestroyCount(): number;
+    getDestroyTargets(): Material;
+    isDestroyOptional(): boolean;
 }
 export declare const Sacrifice: {
     power: number;

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

@@ -1,8 +1,26 @@
+import { Memory } from '../../../Memory';
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class SacrificeRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyCount() {
+        return 2;
+    }
+    getDestroyTargets() {
+        if (this.isDestroyOptional()) {
+            return this.creatures.player(this.player);
+        }
+        else {
+            return this.creatures.player(this.foe);
+        }
+    }
+    isDestroyOptional() {
+        return this.remind(Memory.EffectCount) === 2;
+    }
 }
 export const Sacrifice = {
     power: 4,

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

@@ -1,8 +1,11 @@
+import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class SoulBladeRule extends CardRule {
-    entersEffect: boolean;
+import { DestroyEffect } from '../../EffectTraits';
+declare class SoulBladeRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    getDestroyTargets(): Material;
 }
 export declare const SoulBlade: {
     power: number;

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

@@ -1,8 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
+import { createCardRule } from '../../createCardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class SoulBladeRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        return this.creatures.index((index) => createCardRule(this.game, index).getPower() >= 4);
+    }
 }
 export const SoulBlade = {
     power: 2,

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

@@ -1,9 +1,11 @@
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-declare class WatchTowerRule extends CardRule {
-    challenge: boolean;
-    onChallengeAccepted(): import("@gamepark/rules-api").CustomMove[];
+import { ChallengeEffect, DrawEffect } from '../../EffectTraits';
+declare class WatchTowerRule extends CardRule implements DrawEffect, ChallengeEffect {
+    onEnters(): void;
+    onChallengeAccepted(): void;
+    getDrawCount(): number;
 }
 export declare const WatchTower: {
     power: number;

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

@@ -1,11 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class WatchTowerRule extends CardRule {
-    challenge = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
     onChallengeAccepted() {
-        this.addPendingEffect();
-        return super.onChallengeAccepted();
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        const myCreatures = this.creatures.player(this.player).length;
+        const foeCreatures = this.creatures.player(this.foe).length;
+        return foeCreatures - myCreatures;
     }
 }
 export const WatchTower = {

package/dist/material/decks/highwave/AeliaSteadyHand.d.ts

@@ -2,7 +2,7 @@ import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 declare class AeliaSteadyHandRule extends CardRule {
-    oncePerTurnEffect: boolean;
+    activate(): void;
 }
 export declare const AeliaSteadyHand: {
     power: number;

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

@@ -1,8 +1,11 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class AeliaSteadyHandRule extends CardRule {
-    oncePerTurnEffect = true;
+    activate() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
 }
 export const AeliaSteadyHand = {
     power: 2,

package/dist/material/decks/highwave/BoardingParty.d.ts

@@ -2,7 +2,7 @@ import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 declare class BoardingPartyRule extends CardRule {
-    entersEffect: boolean;
+    onEnters(): void;
 }
 export declare const BoardingParty: {
     power: number;

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

@@ -1,8 +1,11 @@
+import { RuleId } from '../../../rules/RuleId';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
 class BoardingPartyRule extends CardRule {
-    entersEffect = true;
+    onEnters() {
+        this.addPendingEffect(RuleId.BoardingPartyEffect);
+    }
 }
 export const BoardingParty = {
     power: 2,

package/dist/material/decks/highwave/BoardingPartyEffectRule.d.ts

@@ -1,10 +1,11 @@
-import { CustomMove, ItemMove } from '@gamepark/rules-api';
+import { CustomMove } from '@gamepark/rules-api';
 import { DestroyEffectRule } from '../../../rules/DestroyEffectRule';
 export declare class BoardingPartyEffectRule extends DestroyEffectRule {
-    onRuleStart(): never[];
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
     get isBoardingPlayer(): boolean;
     getPlayerMoves(): import("@gamepark/rules-api").MaterialMove[];
     getTargets(): import("@gamepark/rules-api").Material<number, number, number>;
-    afterItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove[];
+    onCardDestroyed(): import("@gamepark/rules-api").MaterialMove[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
+    onRuleEnd(): never[];
 }