@gamepark/skyrift 0.3.0 → 0.4.1

package/dist/rules/PutCardUnderEffectRule.js

@@ -0,0 +1,22 @@
+import { sample } from 'es-toolkit';
+import { LocationType } from '../material/LocationType';
+import { EffectRule } from './EffectRule';
+export class PutCardUnderEffectRule extends EffectRule {
+    get cardRule() {
+        return super.cardRule;
+    }
+    onRuleStart() {
+        const targets = this.cardRule.getPutCardUnderTargets();
+        if (!targets.length) {
+            return this.endEffect();
+        }
+        const randomIndex = sample(targets.getIndexes());
+        return [
+            targets.index(randomIndex).moveItem({
+                type: LocationType.UnderCard,
+                parent: this.effectCardIndex
+            }),
+            ...this.endEffect()
+        ];
+    }
+}

package/dist/rules/PutPowerTokenEffectRule.d.ts

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

package/dist/rules/PutPowerTokenEffectRule.js

@@ -1,24 +1,44 @@
 import { isCreateItemType } from '@gamepark/rules-api';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
 import { EffectRule } from './EffectRule';
 export class PutPowerTokenEffectRule extends EffectRule {
     onRuleStart() {
-        if (!this.getTargets().length) {
+        const targets = this.getTargets();
+        if (!targets.length) {
             return this.endEffect();
         }
+        if (this.cardRule.isAutoPutPowerToken?.()) {
+            this.memorize(Memory.EffectCount, targets.length);
+            return targets.sort((item) => item.location.x).getIndexes().map((index) => this.material(MaterialType.PowerToken).createItem({
+                location: { type: LocationType.CardPowerTokens, parent: index }
+            }));
+        }
+        this.memorize(Memory.EffectCount, this.cardRule.getPutPowerTokenCount?.() ?? 1);
         return [];
     }
     getPlayerMoves() {
-        const powerTokens = this.material(MaterialType.PowerToken);
         return this.getTargets()
             .getIndexes()
-            .map((index) => powerTokens.createItem({ location: { type: LocationType.CardPowerTokens, parent: index } }));
+            .map((index) => this.material(MaterialType.PowerToken).createItem({
+            location: { type: LocationType.CardPowerTokens, parent: index }
+        }));
+    }
+    getTargets() {
+        return this.cardRule.getPutPowerTokenTargets?.() ?? this.material(MaterialType.Card).index(this.effectCardIndex);
     }
     afterItemMove(move) {
         if (isCreateItemType(MaterialType.PowerToken)(move) && move.item.location.type === LocationType.CardPowerTokens) {
-            return this.endEffect();
+            const remaining = this.memorize(Memory.EffectCount, (c) => c - 1);
+            if (remaining <= 0) {
+                return this.endEffect();
+            }
         }
         return [];
     }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
 }

package/dist/rules/ReturnCardEffectRule.d.ts

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

package/dist/rules/ReturnCardEffectRule.js

@@ -0,0 +1,36 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class ReturnCardEffectRule extends EffectRule {
+    onRuleStart() {
+        const targets = this.getTargets();
+        if (!targets.length) {
+            return this.endEffect();
+        }
+        if (this.cardRule.isAutoReturn?.()) {
+            return targets.moveItems((item) => ({ type: LocationType.PlayerHand, player: item.id.back }));
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        const moves = this.getTargets().moveItems((item) => ({
+            type: LocationType.PlayerHand,
+            player: item.id.back
+        }));
+        if (this.cardRule.isReturnOptional?.()) {
+            moves.push(this.customMove(CustomMoveType.EndEffect));
+        }
+        return moves;
+    }
+    getTargets() {
+        return this.cardRule.getReturnTargets?.() ?? this.material(MaterialType.Card).index(this.effectCardIndex);
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerHand) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/dist/rules/ReturnCardRule.d.ts

@@ -1,9 +1,11 @@
 import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../material/CardRule';
+import { ReturnCardEffect } from '../material/EffectTraits';
 import { EffectRule } from './EffectRule';
-export declare abstract class ReturnCardRule extends EffectRule {
-    isOptional: boolean;
+export declare class ReturnCardRule extends EffectRule {
+    get cardRule(): CardRule & ReturnCardEffect;
     onRuleStart(): MaterialMove[];
     getPlayerMoves(): MaterialMove[];
-    abstract getTargets(): Material;
+    getTargets(): Material;
     afterItemMove(move: ItemMove): MaterialMove[];
 }

package/dist/rules/ReturnCardRule.js

@@ -1,22 +1,32 @@
 import { isMoveItemType } from '@gamepark/rules-api';
-import { CustomMoveType } from '../CustomMoveType';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { EffectRule } from './EffectRule';
 export class ReturnCardRule extends EffectRule {
-    isOptional = true;
+    get cardRule() {
+        return super.cardRule;
+    }
     onRuleStart() {
-        if (!this.getTargets().length) {
+        const targets = this.getTargets();
+        if (!targets.length) {
             return this.endEffect();
         }
+        if (this.cardRule.isAutoEffect?.()) {
+            return [
+                ...targets.moveItems((item) => ({ type: LocationType.PlayerHand, player: item.id.back })),
+                ...this.endEffect()
+            ];
+        }
         return [];
     }
     getPlayerMoves() {
-        const moves = this.getTargets().moveItems({ type: LocationType.PlayerHand, player: this.player });
-        if (this.isOptional) {
-            moves.push(this.customMove(CustomMoveType.EndEffect));
-        }
-        return moves;
+        return this.getTargets().moveItems((item) => ({
+            type: LocationType.PlayerHand,
+            player: item.id.back
+        }));
+    }
+    getTargets() {
+        return this.cardRule.getReturnTargets();
     }
     afterItemMove(move) {
         if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerHand) {

package/dist/rules/RuleId.d.ts

@@ -5,43 +5,24 @@ export declare enum RuleId {
     EndPlayerTurn = 4,
     EndRound = 5,
     PrepareNextRound = 6,
-    MayChallenge = 7,
-    Challenge = 8,
-    LoyalSquireEffect = 102,
+    ChallengeEffect = 20,
+    ChallengeResponse = 21,
+    DrawEffect = 22,
+    DiscardEffect = 23,
+    DestroyEffect = 24,
+    StunEffect = 25,
+    ReturnCardEffect = 26,
+    PutPowerTokensEffect = 27,
+    StashPowerTokensEffect = 28,
+    GainCrystalEffect = 29,
+    StealCrystalEffect = 30,
+    PlayCardEffect = 31,
     PrincessLithaEffect = 103,
-    RobbinsMasterOfArmsEffect = 104,
-    OzmaTheMageEffect = 109,
     ArmadaEffect = 110,
-    SoulBladeEffect = 111,
-    CoverOfNightEffect = 112,
-    SacrificeEffect = 113,
-    WatchTowerEffect = 114,
-    ConfluenceEffect = 115,
-    HarvestEffect = 116,
-    DesertRaiderEffect = 201,
-    MetamorphEffect = 202,
     AbiSnakeCharmerEffect = 204,
-    VandalsEffect = 206,
-    MushaFakirEffect = 207,
-    OasisShamanEffect = 208,
-    SandWalkersEffect = 211,
-    WishLampEffect = 212,
-    StarlightBazaarEffect = 213,
-    AncientCurseEffect = 214,
     WindWrathEffect = 215,
-    DeathTrapEffect = 216,
-    SeaScorcherEffect = 601,
-    AeliaSteadyHandEffect = 602,
+    CavernSkulkerEffect = 302,
+    DoomEffect = 315,
     EyeOfSkyEffect = 603,
-    TropicalRuffianEffect = 605,
-    RiggingRaidersEffect = 606,
-    OttoFactotumEffect = 607,
-    OscarScullionEffect = 608,
-    TideRoverEffect = 609,
-    LongJawsSilverEffect = 610,
-    FortunesCourseEffect = 612,
-    DarkArmageddonEffect = 613,
-    BoardingPartyEffect = 614,
-    DawnsDoomEffect = 615,
-    SurpriseLootEffect = 616
+    BoardingPartyEffect = 614
 }

package/dist/rules/RuleId.js

@@ -7,43 +7,24 @@ export var RuleId;
     RuleId[RuleId["EndPlayerTurn"] = 4] = "EndPlayerTurn";
     RuleId[RuleId["EndRound"] = 5] = "EndRound";
     RuleId[RuleId["PrepareNextRound"] = 6] = "PrepareNextRound";
-    RuleId[RuleId["MayChallenge"] = 7] = "MayChallenge";
-    RuleId[RuleId["Challenge"] = 8] = "Challenge";
-    RuleId[RuleId["LoyalSquireEffect"] = 102] = "LoyalSquireEffect";
+    RuleId[RuleId["ChallengeEffect"] = 20] = "ChallengeEffect";
+    RuleId[RuleId["ChallengeResponse"] = 21] = "ChallengeResponse";
+    RuleId[RuleId["DrawEffect"] = 22] = "DrawEffect";
+    RuleId[RuleId["DiscardEffect"] = 23] = "DiscardEffect";
+    RuleId[RuleId["DestroyEffect"] = 24] = "DestroyEffect";
+    RuleId[RuleId["StunEffect"] = 25] = "StunEffect";
+    RuleId[RuleId["ReturnCardEffect"] = 26] = "ReturnCardEffect";
+    RuleId[RuleId["PutPowerTokensEffect"] = 27] = "PutPowerTokensEffect";
+    RuleId[RuleId["StashPowerTokensEffect"] = 28] = "StashPowerTokensEffect";
+    RuleId[RuleId["GainCrystalEffect"] = 29] = "GainCrystalEffect";
+    RuleId[RuleId["StealCrystalEffect"] = 30] = "StealCrystalEffect";
+    RuleId[RuleId["PlayCardEffect"] = 31] = "PlayCardEffect";
     RuleId[RuleId["PrincessLithaEffect"] = 103] = "PrincessLithaEffect";
-    RuleId[RuleId["RobbinsMasterOfArmsEffect"] = 104] = "RobbinsMasterOfArmsEffect";
-    RuleId[RuleId["OzmaTheMageEffect"] = 109] = "OzmaTheMageEffect";
     RuleId[RuleId["ArmadaEffect"] = 110] = "ArmadaEffect";
-    RuleId[RuleId["SoulBladeEffect"] = 111] = "SoulBladeEffect";
-    RuleId[RuleId["CoverOfNightEffect"] = 112] = "CoverOfNightEffect";
-    RuleId[RuleId["SacrificeEffect"] = 113] = "SacrificeEffect";
-    RuleId[RuleId["WatchTowerEffect"] = 114] = "WatchTowerEffect";
-    RuleId[RuleId["ConfluenceEffect"] = 115] = "ConfluenceEffect";
-    RuleId[RuleId["HarvestEffect"] = 116] = "HarvestEffect";
-    RuleId[RuleId["DesertRaiderEffect"] = 201] = "DesertRaiderEffect";
-    RuleId[RuleId["MetamorphEffect"] = 202] = "MetamorphEffect";
     RuleId[RuleId["AbiSnakeCharmerEffect"] = 204] = "AbiSnakeCharmerEffect";
-    RuleId[RuleId["VandalsEffect"] = 206] = "VandalsEffect";
-    RuleId[RuleId["MushaFakirEffect"] = 207] = "MushaFakirEffect";
-    RuleId[RuleId["OasisShamanEffect"] = 208] = "OasisShamanEffect";
-    RuleId[RuleId["SandWalkersEffect"] = 211] = "SandWalkersEffect";
-    RuleId[RuleId["WishLampEffect"] = 212] = "WishLampEffect";
-    RuleId[RuleId["StarlightBazaarEffect"] = 213] = "StarlightBazaarEffect";
-    RuleId[RuleId["AncientCurseEffect"] = 214] = "AncientCurseEffect";
     RuleId[RuleId["WindWrathEffect"] = 215] = "WindWrathEffect";
-    RuleId[RuleId["DeathTrapEffect"] = 216] = "DeathTrapEffect";
-    RuleId[RuleId["SeaScorcherEffect"] = 601] = "SeaScorcherEffect";
-    RuleId[RuleId["AeliaSteadyHandEffect"] = 602] = "AeliaSteadyHandEffect";
+    RuleId[RuleId["CavernSkulkerEffect"] = 302] = "CavernSkulkerEffect";
+    RuleId[RuleId["DoomEffect"] = 315] = "DoomEffect";
     RuleId[RuleId["EyeOfSkyEffect"] = 603] = "EyeOfSkyEffect";
-    RuleId[RuleId["TropicalRuffianEffect"] = 605] = "TropicalRuffianEffect";
-    RuleId[RuleId["RiggingRaidersEffect"] = 606] = "RiggingRaidersEffect";
-    RuleId[RuleId["OttoFactotumEffect"] = 607] = "OttoFactotumEffect";
-    RuleId[RuleId["OscarScullionEffect"] = 608] = "OscarScullionEffect";
-    RuleId[RuleId["TideRoverEffect"] = 609] = "TideRoverEffect";
-    RuleId[RuleId["LongJawsSilverEffect"] = 610] = "LongJawsSilverEffect";
-    RuleId[RuleId["FortunesCourseEffect"] = 612] = "FortunesCourseEffect";
-    RuleId[RuleId["DarkArmageddonEffect"] = 613] = "DarkArmageddonEffect";
     RuleId[RuleId["BoardingPartyEffect"] = 614] = "BoardingPartyEffect";
-    RuleId[RuleId["DawnsDoomEffect"] = 615] = "DawnsDoomEffect";
-    RuleId[RuleId["SurpriseLootEffect"] = 616] = "SurpriseLootEffect";
 })(RuleId || (RuleId = {}));

package/dist/rules/StartPlayerTurnRule.js

@@ -11,24 +11,24 @@ export class StartPlayerTurnRule extends PlayerTurnRule {
         const moves = [];
         this.memorize(Memory.CurrentPlayer, this.player);
         this.memorize(Memory.CardsPlayed, [], this.player);
-        this.memorize(Memory.OncePerTurnEffects, []);
+        this.memorize(Memory.ActivatedCards, []);
         this.forget(Memory.Suit);
         const actionCards = this.material(MaterialType.Card)
             .location(LocationType.PlayArea)
             .player(this.player)
             .filter((card) => cardProperties[card.id.front].type === CardType.Action);
-        moves.push(...actionCards.moveItems({ type: LocationType.PlayerDiscard, player: this.player }));
+        moves.push(...actionCards.moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back })));
         for (const cardRule of new PlayerHelper(this.game, this.player).cardRules) {
-            moves.push(...cardRule.onPlayerTurnStart(this.player));
+            cardRule.onPlayerTurnStart?.();
         }
         for (const cardRule of new PlayerHelper(this.game, this.nextPlayer).cardRules) {
-            moves.push(...cardRule.onPlayerTurnStart(this.player));
+            cardRule.onFoeTurnStart?.();
         }
         const stunTokens = this.material(MaterialType.StunToken).location(LocationType.CardStunTokens);
         moves.push(...stunTokens.deleteItems(1));
         const pendingEffects = this.remind(Memory.PendingEffects);
         if (pendingEffects.length > 0) {
-            moves.push(...new PlayerHelper(this.game, this.player).getCardRule(pendingEffects[0].cardIndex).startEffect());
+            moves.push(...new PlayerHelper(this.game, this.player).startEffect(pendingEffects[0]));
         }
         else {
             moves.push(this.startRule(RuleId.PlayCard));

package/dist/rules/StashPowerTokensEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { StashPowerTokenEffect } from '../material/EffectTraits';
+import { EffectRule } from './EffectRule';
+export declare class StashPowerTokensEffectRule extends EffectRule<StashPowerTokenEffect> {
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove[];
+}

package/dist/rules/StashPowerTokensEffectRule.js

@@ -0,0 +1,15 @@
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class StashPowerTokensEffectRule extends EffectRule {
+    onRuleStart() {
+        const count = this.cardRule.getStashPowerTokenCount?.() ?? 1;
+        return [
+            this.material(MaterialType.PowerToken).createItem({
+                location: { type: LocationType.PlayerStash, player: this.player },
+                quantity: count
+            }),
+            ...this.endEffect()
+        ];
+    }
+}

package/dist/rules/StealCrystalEffectRule.js

@@ -4,9 +4,9 @@ import { EffectRule } from './EffectRule';
 export class StealCrystalEffectRule extends EffectRule {
     onRuleStart() {
         const moves = this.endEffect();
-        const opponentCrystals = this.material(MaterialType.Crystal).location(LocationType.PlayerCrystals).player(this.nextPlayer);
-        if (opponentCrystals.length > 0) {
-            moves.unshift(opponentCrystals.moveItem({ type: LocationType.PlayerCrystals, player: this.player }));
+        const foeCrystals = this.material(MaterialType.Crystal).location(LocationType.PlayerCrystals).player(this.nextPlayer);
+        if (foeCrystals.length > 0) {
+            moves.unshift(foeCrystals.moveItem({ type: LocationType.PlayerCrystals, player: this.player }));
         }
         return moves;
     }

package/dist/rules/StunCardRule.d.ts

@@ -1,9 +1,11 @@
 import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { StunEffect } from '../material/EffectTraits';
 import { EffectRule } from './EffectRule';
-export declare class StunCardRule extends EffectRule {
-    stunCount: number;
+export declare class StunCardRule extends EffectRule<StunEffect> {
     onRuleStart(): MaterialMove[];
     getPlayerMoves(): MaterialMove[];
+    stunTargets(): MaterialMove[];
     getTargets(): Material;
     afterItemMove(move: ItemMove): MaterialMove[];
+    onRuleEnd(): never[];
 }

package/dist/rules/StunCardRule.js

@@ -1,40 +1,45 @@
 import { isCreateItemType } from '@gamepark/rules-api';
-import { cardProperties } from '../material/CardProperties';
-import { CardType } from '../material/CardType';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
 import { EffectRule } from './EffectRule';
 export class StunCardRule extends EffectRule {
-    stunCount = 1;
     onRuleStart() {
+        this.memorize(Memory.EffectCount, []);
         if (!this.getTargets().length) {
             return this.endEffect();
         }
+        if (this.cardRule.isAutoStun?.()) {
+            return this.stunTargets();
+        }
         return [];
     }
     getPlayerMoves() {
-        const creatures = this.getTargets().getIndexes();
-        const moves = [];
-        for (const creatureIndex of creatures) {
-            moves.push(this.material(MaterialType.StunToken).createItem({
-                location: {
-                    type: LocationType.CardStunTokens,
-                    parent: creatureIndex
-                },
-                quantity: this.stunCount
-            }));
-        }
-        return moves;
+        return this.stunTargets();
+    }
+    stunTargets() {
+        const stunCount = this.cardRule.getStunCount?.() ?? 1;
+        return this.getTargets().getIndexes().map((creatureIndex) => this.material(MaterialType.StunToken).createItem({
+            location: { type: LocationType.CardStunTokens, parent: creatureIndex },
+            quantity: stunCount
+        }));
     }
     getTargets() {
-        return this.material(MaterialType.Card)
-            .location(LocationType.PlayArea)
-            .id((id) => cardProperties[id.front].type === CardType.Creature);
+        const stunned = this.remind(Memory.EffectCount);
+        const targets = this.cardRule.getStunTargets?.() ?? this.cardRule.creatures;
+        return targets.index((index) => !stunned.includes(index));
     }
     afterItemMove(move) {
         if (isCreateItemType(MaterialType.StunToken)(move) && move.item.location.type === LocationType.CardStunTokens) {
-            return this.endEffect();
+            const stunned = this.memorize(Memory.EffectCount, (s) => [...s, move.item.location.parent]);
+            if (stunned.length >= (this.cardRule.getStunTargetsCount?.() ?? 1) || !this.getTargets().length) {
+                return this.endEffect();
+            }
         }
         return [];
     }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
 }

package/dist/rules/StunEffectRule.d.ts

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

package/dist/rules/StunEffectRule.js

@@ -0,0 +1,45 @@
+import { isCreateItemType } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Memory } from '../Memory';
+import { EffectRule } from './EffectRule';
+export class StunEffectRule extends EffectRule {
+    onRuleStart() {
+        this.memorize(Memory.EffectCount, []);
+        if (!this.getTargets().length) {
+            return this.endEffect();
+        }
+        if (this.cardRule.isAutoStun?.()) {
+            return this.stunTargets();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.stunTargets();
+    }
+    stunTargets() {
+        const stunCount = this.cardRule.getStunCount?.() ?? 1;
+        return this.getTargets().sort((item) => item.location.x).getIndexes().map((creatureIndex) => this.material(MaterialType.StunToken).createItem({
+            location: { type: LocationType.CardStunTokens, parent: creatureIndex },
+            quantity: stunCount
+        }));
+    }
+    getTargets() {
+        const stunned = this.remind(Memory.EffectCount);
+        const targets = this.cardRule.getStunTargets?.() ?? this.cardRule.creatures;
+        return targets.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 ((!this.cardRule.isAutoStun?.() && stunned.length >= (this.cardRule.getStunTargetsCount?.() ?? 1)) || !this.getTargets().length) {
+                return this.endEffect();
+            }
+        }
+        return [];
+    }
+    onRuleEnd() {
+        this.forget(Memory.EffectCount);
+        return [];
+    }
+}

package/dist/rules/SwitchSideEffectRule.d.ts

@@ -0,0 +1,11 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { CardRule } from '../material/CardRule';
+import { SwitchSideEffect } from '../material/EffectTraits';
+import { EffectRule } from './EffectRule';
+export declare class SwitchSideEffectRule extends EffectRule {
+    get cardRule(): CardRule & SwitchSideEffect;
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    getTargets(): Material;
+    afterItemMove(move: ItemMove): MaterialMove[];
+}

package/dist/rules/SwitchSideEffectRule.js

@@ -0,0 +1,33 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { cardProperties } from '../material/CardProperties';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class SwitchSideEffectRule extends EffectRule {
+    get cardRule() {
+        return super.cardRule;
+    }
+    onRuleStart() {
+        const targets = this.getTargets();
+        if (!targets.length) {
+            return this.endEffect();
+        }
+        return [];
+    }
+    getPlayerMoves() {
+        return this.getTargets().moveItems((item) => ({
+            type: LocationType.PlayArea,
+            player: item.location.player === this.player ? this.nextPlayer : this.player,
+            id: cardProperties[item.id.front].type
+        }));
+    }
+    getTargets() {
+        return this.cardRule.getSwitchSideTargets();
+    }
+    afterItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/skyrift",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "The rules of SkyRift adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -26,9 +26,9 @@
     "es-toolkit": "^1.39.10"
   },
   "devDependencies": {
-    "@gamepark/rules-api": "~7.2.0",
+    "@gamepark/rules-api": "~7.5.0",
     "es-toolkit": "^1.43.0",
     "vitest": "^4.0.15"
   },
-  "gitHead": "f50ba0de0d312d2424e9bb27f567966975c5e72d"
+  "gitHead": "e9084054f7da0b172340a4a24de6f26170bd06c5"
 }