@gamepark/skyrift 0.3.0 → 0.4.1

package/dist/rules/ChallengeResponseRule.js

@@ -0,0 +1,31 @@
+import { isCreateItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { EffectRule } from './EffectRule';
+export class ChallengeResponseRule extends EffectRule {
+    getPlayerMoves() {
+        return [this.material(MaterialType.Crystal).createItem({ location: { type: LocationType.Stake } }), this.customMove(CustomMoveType.ConcedeRound)];
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.Crystal)(move) && move.item.location.type === LocationType.Stake) {
+            this.cardRule.onChallengeAccepted?.();
+            return this.endEffect();
+        }
+        return [];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ConcedeRound) {
+            this.memorize(Memory.ChallengeConceded, this.player);
+            this.cardRule.onChallengeDeclined?.();
+            const moves = this.endEffect();
+            const stake = this.material(MaterialType.Crystal).location(LocationType.Stake);
+            const stakeQuantity = stake.getQuantity();
+            if (stakeQuantity > 1)
+                moves.unshift(stake.deleteItem(stakeQuantity - 1));
+            return moves;
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/rules/ChooseStartPlayerEffectRule.d.ts

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

package/dist/rules/ChooseStartPlayerEffectRule.js

@@ -0,0 +1,15 @@
+import { CustomMoveType } from '../CustomMoveType';
+import { Memory } from '../Memory';
+import { EffectRule } from './EffectRule';
+export class ChooseStartPlayerEffectRule extends EffectRule {
+    getPlayerMoves() {
+        return this.game.players.map((player) => this.customMove(CustomMoveType.ChoosePlayer, player));
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChoosePlayer) {
+            this.memorize(Memory.NextRoundStartPlayer, move.data);
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/rules/DestroyEffectRule.d.ts

@@ -1,8 +1,11 @@
 import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { DestroyEffect } from '../material/EffectTraits';
 import { EffectRule } from './EffectRule';
-export declare abstract class DestroyEffectRule extends EffectRule {
+export declare class DestroyEffectRule extends EffectRule<DestroyEffect> {
     onRuleStart(): MaterialMove[];
     getPlayerMoves(): MaterialMove[];
-    abstract getTargets(): Material;
+    getTargets(): Material;
     afterItemMove(move: ItemMove): MaterialMove[];
+    onCardDestroyed(): MaterialMove[];
+    onRuleEnd(): never[];
 }

package/dist/rules/DestroyEffectRule.js

@@ -1,21 +1,44 @@
 import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
 import { EffectRule } from './EffectRule';
 export class DestroyEffectRule extends EffectRule {
     onRuleStart() {
-        if (!this.getTargets().length) {
+        const targets = this.getTargets();
+        if (!targets.length) {
             return this.endEffect();
         }
+        if (this.cardRule.isAutoDestroy?.()) {
+            this.memorize(Memory.EffectCount, targets.length);
+            return targets.moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back }));
+        }
+        this.memorize(Memory.EffectCount, this.cardRule.getDestroyCount?.() ?? 1);
         return [];
     }
     getPlayerMoves() {
-        return this.getTargets().moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.location.player }));
+        const moves = this.getTargets().moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back }));
+        if (this.cardRule.isDestroyOptional?.()) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    getTargets() {
+        return this.cardRule.getDestroyTargets();
     }
     afterItemMove(move) {
         if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
-            return this.endEffect();
+            return this.onCardDestroyed();
         }
         return [];
     }
+    onCardDestroyed() {
+        const remaining = this.memorize(Memory.EffectCount, (c) => c - 1);
+        return remaining <= 0 || !this.getTargets().length ? this.endEffect() : [];
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
 }

package/dist/rules/DiscardEffectRule.d.ts

@@ -1,8 +1,10 @@
 import { ItemMove, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { DiscardEffect } from '../material/EffectTraits';
 import { EffectRule } from './EffectRule';
-export declare class DiscardEffectRule extends EffectRule {
-    discardCount: number;
-    onRuleStart(): never[];
+export declare class DiscardEffectRule extends EffectRule<DiscardEffect> {
+    get discardCount(): number;
+    onRuleStart(): MaterialMove[];
+    getTargets(): import("@gamepark/rules-api").Material<number, number, number>;
     getPlayerMoves(): MaterialMove[];
     afterItemMove(move: ItemMove): MaterialMove[];
     onDiscard(_move: MoveItem): MaterialMove[];

package/dist/rules/DiscardEffectRule.js

@@ -4,11 +4,24 @@ import { MaterialType } from '../material/MaterialType';
 import { Memory } from '../Memory';
 import { EffectRule } from './EffectRule';
 export class DiscardEffectRule extends EffectRule {
-    discardCount = 1;
+    get discardCount() {
+        return this.cardRule.getDiscardCount?.() ?? 1;
+    }
     onRuleStart() {
-        this.memorize(Memory.EffectCount, 0);
+        const targets = this.getTargets();
+        if (!targets.length) {
+            return this.endEffect();
+        }
+        if (this.cardRule.isAutoDiscard?.()) {
+            this.memorize(Memory.EffectCount, targets.length);
+            return targets.moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.location.player }));
+        }
+        this.memorize(Memory.EffectCount, this.discardCount);
         return [];
     }
+    getTargets() {
+        return this.cardRule.getDiscardTargets?.() ?? this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.player);
+    }
     getPlayerMoves() {
         return this.material(MaterialType.Card)
             .location(LocationType.PlayerHand)
@@ -22,8 +35,8 @@ export class DiscardEffectRule extends EffectRule {
         return [];
     }
     onDiscard(_move) {
-        const count = this.memorize(Memory.EffectCount, (count) => count + 1);
-        if (count >= this.discardCount) {
+        const remaining = this.memorize(Memory.EffectCount, (c) => c - 1);
+        if (remaining <= 0) {
             return this.endEffect();
         }
         return [];

package/dist/rules/DrawEffectRule.d.ts

@@ -1,6 +1,8 @@
 import { MaterialMove } from '@gamepark/rules-api';
+import { DrawEffect } from '../material/EffectTraits';
 import { EffectRule } from './EffectRule';
-export declare class DrawEffectRule extends EffectRule {
+export declare class DrawEffectRule extends EffectRule<DrawEffect> {
     onRuleStart(): MaterialMove[];
-    getDrawCount(): number;
+    get drawingPlayer(): number;
+    get drawCount(): number;
 }

package/dist/rules/DrawEffectRule.js

@@ -2,14 +2,17 @@ import { CustomMoveType } from '../CustomMoveType';
 import { EffectRule } from './EffectRule';
 export class DrawEffectRule extends EffectRule {
     onRuleStart() {
-        const moves = this.endEffect();
-        const drawCount = this.getDrawCount();
+        const moves = [];
+        const drawCount = this.drawCount;
         if (drawCount > 0) {
-            moves.unshift(this.customMove(CustomMoveType.Draw, { player: this.player, quantity: drawCount }));
+            moves.push(this.customMove(CustomMoveType.Draw, { player: this.drawingPlayer, quantity: drawCount }));
         }
-        return moves;
+        return [...moves, ...this.endEffect()];
     }
-    getDrawCount() {
-        return 1;
+    get drawingPlayer() {
+        return this.cardRule.getDrawPlayer?.() ?? this.player;
+    }
+    get drawCount() {
+        return this.cardRule.getDrawCount?.() ?? 1;
     }
 }

package/dist/rules/EffectRule.d.ts

@@ -1,7 +1,8 @@
 import { CustomMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
-export declare class EffectRule extends PlayerTurnRule {
+import { CardRule } from '../material/CardRule';
+export declare class EffectRule<T = unknown> extends PlayerTurnRule {
     get effectCardIndex(): number;
-    get cardRule(): import("../material/CardRule").CardRule;
+    get cardRule(): CardRule & T;
     endEffect(): MaterialMove[];
     onCustomMove(move: CustomMove): MaterialMove[];
     onEndEffect(): MaterialMove[];

package/dist/rules/EffectRule.js

@@ -1,5 +1,6 @@
 import { PlayerTurnRule } from '@gamepark/rules-api';
 import { CustomMoveType } from '../CustomMoveType';
+import { createCardRule } from '../material/createCardRule';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { Memory } from '../Memory';
@@ -10,7 +11,7 @@ export class EffectRule extends PlayerTurnRule {
         return this.remind(Memory.PendingEffects)[0].cardIndex;
     }
     get cardRule() {
-        return new PlayerHelper(this.game, this.player).getCardRule(this.effectCardIndex);
+        return createCardRule(this.game, this.effectCardIndex);
     }
     endEffect() {
         return [this.customMove(CustomMoveType.EndEffect)];
@@ -25,7 +26,12 @@ export class EffectRule extends PlayerTurnRule {
         this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
         const pendingEffects = this.remind(Memory.PendingEffects);
         if (pendingEffects.length > 0) {
-            return new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex).startEffect();
+            return new PlayerHelper(this.game, this.player).startEffect(pendingEffects[0]);
+        }
+        const concededBy = this.remind(Memory.ChallengeConceded);
+        if (concededBy !== undefined) {
+            this.forget(Memory.ChallengeConceded);
+            return [this.startPlayerTurn(RuleId.EndRound, concededBy)];
         }
         const crystalsInStake = this.material(MaterialType.Crystal).location(LocationType.Stake).getQuantity();
         if (crystalsInStake === 0) {
@@ -37,7 +43,7 @@ export class EffectRule extends PlayerTurnRule {
             return [this.startPlayerTurn(RuleId.EndPlayerTurn, currentPlayer)];
         }
         else {
-            return [this.startPlayerTurn(RuleId.PlayCard, this.remind(Memory.CurrentPlayer))];
+            return [this.startPlayerTurn(RuleId.PlayCard, currentPlayer)];
         }
     }
 }

package/dist/rules/EndRoundRule.js

@@ -1,4 +1,5 @@
 import { PlayerTurnRule } from '@gamepark/rules-api';
+import { createCardRule } from '../material/createCardRule';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { Memory } from '../Memory';
@@ -13,16 +14,7 @@ export class EndRoundRule extends PlayerTurnRule {
         const stake = this.material(MaterialType.Crystal).location(LocationType.Stake);
         const stakeQuantity = stake.getQuantity();
         if (stakeQuantity) {
-            const challengeConceded = this.remind(Memory.ChallengeConceded);
-            if (challengeConceded) {
-                this.forget(Memory.ChallengeConceded);
-                if (stakeQuantity > 1)
-                    moves.push(stake.deleteItem(stakeQuantity - 1));
-                moves.push(stake.moveItem({ type: LocationType.PlayerCrystals, player: winner }, 1));
-            }
-            else {
-                moves.push(stake.moveItem({ type: LocationType.PlayerCrystals, player: winner }, stakeQuantity));
-            }
+            moves.push(stake.moveItem({ type: LocationType.PlayerCrystals, player: winner }, stakeQuantity));
         }
         const loserCards = this.material(MaterialType.Card)
             .location(LocationType.PlayArea)
@@ -35,19 +27,21 @@ export class EndRoundRule extends PlayerTurnRule {
             .sort((item) => item.location.x)
             .getIndexes();
         for (const cardIndex of loserCards) {
-            const cardRule = new PlayerHelper(this.game, loser).getCardRule(cardIndex);
-            moves.push(...cardRule.onRoundEnd(false));
+            const cardRule = createCardRule(this.game, cardIndex);
+            cardRule.onSkirmishEnd?.();
+            cardRule.onSkirmishLost?.();
         }
         for (const cardIndex of winnerCards) {
-            const cardRule = new PlayerHelper(this.game, winner).getCardRule(cardIndex);
-            moves.push(...cardRule.onRoundEnd(true));
+            const cardRule = createCardRule(this.game, cardIndex);
+            cardRule.onSkirmishEnd?.();
+            cardRule.onSkirmishWin?.();
         }
         const pendingEffects = this.remind(Memory.PendingEffects);
-        if (pendingEffects.length === 0) {
-            moves.push(this.startRule(RuleId.PrepareNextRound));
+        if (pendingEffects.length > 0) {
+            moves.push(...new PlayerHelper(this.game, this.player).startEffect(pendingEffects[0]));
         }
         else {
-            moves.push(...new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex).startEffect());
+            moves.push(this.startRule(RuleId.PrepareNextRound));
         }
         return moves;
     }

package/dist/rules/GainPowerTokensEffectRule.d.ts

@@ -0,0 +1,8 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../material/CardRule';
+import { GainPowerTokenEffect } from '../material/EffectTraits';
+import { EffectRule } from './EffectRule';
+export declare class GainPowerTokensEffectRule extends EffectRule {
+    get cardRule(): CardRule & GainPowerTokenEffect;
+    onRuleStart(): MaterialMove[];
+}

package/dist/rules/GainPowerTokensEffectRule.js

@@ -0,0 +1,25 @@
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class GainPowerTokensEffectRule extends EffectRule {
+    get cardRule() {
+        return super.cardRule;
+    }
+    onRuleStart() {
+        const moves = [];
+        for (const index of this.cardRule.getGainPowerTokenTargets().getIndexes()) {
+            moves.push(this.material(MaterialType.PowerToken).createItem({
+                location: { type: LocationType.CardPowerTokens, parent: index }
+            }));
+        }
+        const stashCount = this.cardRule.getGainPowerTokenStashCount?.() ?? 0;
+        if (stashCount > 0) {
+            moves.push(this.material(MaterialType.PowerToken).createItem({
+                location: { type: LocationType.PlayerStash, player: this.player },
+                quantity: stashCount
+            }));
+        }
+        moves.push(...this.endEffect());
+        return moves;
+    }
+}

package/dist/rules/MulliganEffectRule.d.ts

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

package/dist/rules/MulliganEffectRule.js

@@ -0,0 +1,19 @@
+import { CustomMoveType } from '../CustomMoveType';
+import { Memory } from '../Memory';
+import { DiscardEffectRule } from './DiscardEffectRule';
+export class MulliganEffectRule extends DiscardEffectRule {
+    get discardCount() {
+        return Infinity;
+    }
+    getPlayerMoves() {
+        const moves = super.getPlayerMoves();
+        moves.push(this.customMove(CustomMoveType.Pass));
+        return moves;
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.Pass) {
+            return [this.customMove(CustomMoveType.Draw, { player: this.player, quantity: this.remind(Memory.EffectCount) }), ...this.endEffect()];
+        }
+        return super.onCustomMove(move);
+    }
+}

package/dist/rules/PlayCardEffectRule.d.ts

@@ -0,0 +1,9 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { PlayCardEffect } from '../material/EffectTraits';
+import { EffectRule } from './EffectRule';
+export declare class PlayCardEffectRule extends EffectRule<PlayCardEffect> {
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    getTargets(): Material;
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/rules/PlayCardEffectRule.js

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

package/dist/rules/PlayCardRule.js

@@ -1,6 +1,7 @@
 import { isMoveItemType, PlayerTurnRule } from '@gamepark/rules-api';
 import { CustomMoveType } from '../CustomMoveType';
 import { cardProperties } from '../material/CardProperties';
+import { createCardRule } from '../material/createCardRule';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { Memory } from '../Memory';
@@ -25,37 +26,34 @@ export class PlayCardRule extends PlayerTurnRule {
                 moves.push(powerTokensStash.moveItem({ type: LocationType.CardPowerTokens, parent: index }, 1));
             }
         }
-        const usedEffects = this.remind(Memory.OncePerTurnEffects);
         for (const cardRule of playerHelper.cardRules) {
-            if (cardRule.oncePerTurnEffect && !cardRule.isStunned() && !usedEffects.some((effect) => effect.cardIndex === cardRule.index)) {
+            if (cardRule.canActivate()) {
                 moves.push(this.customMove(CustomMoveType.ActivateCard, cardRule.index));
             }
         }
         return moves;
     }
     get cardsICanPlay() {
-        const playerHelper = new PlayerHelper(this.game);
         return this.material(MaterialType.Card)
             .location(LocationType.PlayerHand)
             .player(this.player)
-            .index((index) => playerHelper.getCardRule(index).canBePlayed());
+            .index((index) => createCardRule(this.game, index).canBePlayed());
     }
     afterItemMove(move) {
-        const moves = [];
         if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
             const playerHelper = new PlayerHelper(this.game, this.player);
-            moves.push(...playerHelper.onCardPlayed(move.itemIndex));
+            playerHelper.onCardPlayed(move.itemIndex);
             const pendingEffects = this.remind(Memory.PendingEffects);
             if (pendingEffects.length > 0) {
-                return [...moves, ...playerHelper.getCardRule(pendingEffects[0].cardIndex).startEffect()];
+                return playerHelper.startEffect(pendingEffects[0]);
             }
         }
         if (isMoveItemType(MaterialType.Card)(move) || isMoveItemType(MaterialType.PowerToken)(move)) {
             if (this.remind(Memory.CardsPlayed, this.player).length > 0 && this.hasMorePower()) {
-                moves.push(this.startRule(RuleId.EndPlayerTurn));
+                return [this.startRule(RuleId.EndPlayerTurn)];
             }
         }
-        return moves;
+        return [];
     }
     onCustomMove(move) {
         if (move.type === CustomMoveType.ConcedeRound) {
@@ -64,9 +62,11 @@ export class PlayCardRule extends PlayerTurnRule {
         }
         else if (move.type === CustomMoveType.ActivateCard) {
             const cardIndex = move.data;
-            const cardRule = new PlayerHelper(this.game, this.player).getCardRule(cardIndex);
-            this.memorize(Memory.OncePerTurnEffects, (effects) => [...effects, { cardIndex }]);
-            return cardRule.startEffect();
+            this.memorize(Memory.ActivatedCards, (cards) => [...cards, cardIndex]);
+            const cardRule = createCardRule(this.game, cardIndex);
+            cardRule.activate?.();
+            const pendingEffects = this.remind(Memory.PendingEffects);
+            return pendingEffects.length > 0 ? cardRule.startEffect(pendingEffects[0]) : [];
         }
         return [];
     }

package/dist/rules/PlayerHelper.d.ts

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

package/dist/rules/PlayerHelper.js

@@ -1,8 +1,8 @@
 import { MaterialRulesPart } from '@gamepark/rules-api';
 import { sumBy } from 'es-toolkit';
 import { cardProperties } from '../material/CardProperties';
+import { createCardRule } from '../material/createCardRule';
 import { CardSuit } from '../material/CardSuit';
-import { CardType } from '../material/CardType';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { OngoingEffectType } from '../material/OngoingEffect';
@@ -13,19 +13,21 @@ export class PlayerHelper extends MaterialRulesPart {
         super(game);
         this.player = player;
     }
-    getCardRule(cardIndex, card = this.material(MaterialType.Card).getItem(cardIndex).id.front) {
-        const Rule = cardProperties[card].rule;
-        return new Rule(this.game, cardIndex);
-    }
     getPendingEffectCardRule() {
         const cardIndex = this.remind(Memory.PendingEffects)[0].cardIndex;
-        return this.getCardRule(cardIndex);
+        return createCardRule(this.game, cardIndex);
+    }
+    startEffect(effect) {
+        return createCardRule(this.game, effect.cardIndex).startEffect(effect);
     }
     get cardsInPlay() {
         return this.material(MaterialType.Card).location(LocationType.PlayArea).player(this.player);
     }
     get cardRules() {
-        return this.cardsInPlay.getIndexes().map((index) => this.getCardRule(index));
+        return this.cardsInPlay.getIndexes().map((index) => createCardRule(this.game, index));
+    }
+    hasCard(card) {
+        return this.cardsInPlay.id((id) => id.front === card).length > 0;
     }
     getPower() {
         return sumBy(this.cardRules, (rule) => rule.getPower());
@@ -38,9 +40,7 @@ export class PlayerHelper extends MaterialRulesPart {
     }
     onCardPlayed(cardIndex) {
         this.memorize(Memory.CardsPlayed, (cards) => [...cards, cardIndex], this.player);
-        this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => !(e.type === OngoingEffectType.ForcedSuit &&
-            this.material(MaterialType.Card).getItem(e.cardIndex).location.player !== this.player)));
-        const cardRule = this.getCardRule(cardIndex);
+        const cardRule = createCardRule(this.game, cardIndex);
         if (!this.remind(Memory.Suit)) {
             const suit = cardProperties[cardRule.card].suit;
             if (suit === CardSuit.Day || suit === CardSuit.Night) {
@@ -48,21 +48,23 @@ export class PlayerHelper extends MaterialRulesPart {
             }
         }
         const ongoingEffects = this.remind(Memory.OngoingEffects);
-        const deathTrap = ongoingEffects.find((e) => e.type === OngoingEffectType.DeathTrap);
-        if (deathTrap && cardProperties[cardRule.card].type === CardType.Creature) {
-            this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => e.type !== OngoingEffectType.DeathTrap));
-            this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: deathTrap.cardIndex }]);
-            return [];
+        const preventEffect = ongoingEffects.find(e => {
+            if (e.type !== OngoingEffectType.PreventEffects)
+                return false;
+            const source = createCardRule(this.game, e.cardIndex);
+            return source.preventEnterEffects(cardIndex);
+        });
+        if (preventEffect) {
+            createCardRule(this.game, preventEffect.cardIndex).onCardEnters?.(cardRule.card, this.player);
         }
-        const moves = [];
-        const cardsInPlay = this.material(MaterialType.Card).location(LocationType.PlayArea);
-        for (const index of cardsInPlay.getIndexes()) {
-            if (index !== cardIndex) {
-                const otherCardRule = this.getCardRule(index);
-                moves.push(...otherCardRule.onCardEnters(cardRule.card, this.player));
+        else {
+            const cardsInPlay = this.material(MaterialType.Card).location(LocationType.PlayArea);
+            for (const index of cardsInPlay.getIndexes()) {
+                if (index !== cardIndex) {
+                    createCardRule(this.game, index).onCardEnters?.(cardRule.card, this.player);
+                }
             }
+            cardRule.onEnters?.();
         }
-        moves.push(...cardRule.onEnters());
-        return moves;
     }
 }

package/dist/rules/PrepareNextRoundRule.js

@@ -3,15 +3,18 @@ import { CustomMoveType } from '../CustomMoveType';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { Memory } from '../Memory';
+import { createCardRule } from '../material/createCardRule';
 import { RuleId } from './RuleId';
 export class PrepareNextRoundRule extends MaterialRulesPart {
     onRuleStart() {
         const nextRoundStartPlayer = this.remind(Memory.NextRoundStartPlayer);
         const moves = [];
+        const allCardsInPlay = this.material(MaterialType.Card).location(LocationType.PlayArea);
+        const cardsToDiscard = allCardsInPlay.index((index) => !createCardRule(this.game, index).survivesSkirmish);
         for (const player of this.game.players) {
-            const cardsInPlay = this.material(MaterialType.Card).location(LocationType.PlayArea).player(player);
-            if (cardsInPlay.length > 0) {
-                moves.push(cardsInPlay.moveItemsAtOnce({ type: LocationType.PlayerDiscard, player }));
+            const playerCards = cardsToDiscard.id((id) => id.back === player);
+            if (playerCards.length > 0) {
+                moves.push(playerCards.moveItemsAtOnce({ type: LocationType.PlayerDiscard, player }));
             }
         }
         moves.push(this.customMove(CustomMoveType.Draw, { player: nextRoundStartPlayer, quantity: 3 }));

package/dist/rules/PutCardUnderEffectRule.d.ts

@@ -0,0 +1,7 @@
+import { CardRule } from '../material/CardRule';
+import { PutCardUnderEffect } from '../material/EffectTraits';
+import { EffectRule } from './EffectRule';
+export declare class PutCardUnderEffectRule extends EffectRule {
+    get cardRule(): CardRule & PutCardUnderEffect;
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+}