@gamepark/skyrift 0.5.0 → 0.6.0

package/dist/rules/PrepareNextRoundRule.js

@@ -2,15 +2,17 @@ import { MaterialRulesPart } from '@gamepark/rules-api';
 import { CustomMoveType } from '../CustomMoveType';
 import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
+import { OngoingEffectType } from '../material/OngoingEffect';
 import { Memory } from '../Memory';
-import { createCardRule } from '../material/createCardRule';
+import { EffectsHelper } from './EffectsHelper';
 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);
+        const survivingCards = new EffectsHelper(this.game).getActiveOngoingEffects(OngoingEffectType.SurvivesSkirmish).map((e) => e.cardIndex);
+        const cardsToDiscard = allCardsInPlay.index((index) => !survivingCards.includes(index));
         for (const player of this.game.players) {
             const playerCards = cardsToDiscard.id((id) => id.back === player);
             if (playerCards.length > 0) {

package/dist/rules/RuleId.d.ts

@@ -18,11 +18,15 @@ export declare enum RuleId {
     StealCrystalEffect = 30,
     PlayCardEffect = 31,
     MulliganEffect = 32,
+    SwitchSideEffect = 33,
     PrincessLithaEffect = 103,
-    AbiSnakeCharmerEffect = 204,
     WindWrathEffect = 215,
     CavernSkulkerEffect = 302,
     DoomEffect = 315,
+    CopyPlayEffect = 503,
+    EmpressSamaEffect = 509,
+    LotusMuseEffect = 510,
+    AzureDragonsPeaceEffect = 513,
     CycleKeeperEffect = 409,
     CaveInEffect = 413,
     EyeOfSkyEffect = 603,

package/dist/rules/RuleId.js

@@ -20,11 +20,15 @@ export var RuleId;
     RuleId[RuleId["StealCrystalEffect"] = 30] = "StealCrystalEffect";
     RuleId[RuleId["PlayCardEffect"] = 31] = "PlayCardEffect";
     RuleId[RuleId["MulliganEffect"] = 32] = "MulliganEffect";
+    RuleId[RuleId["SwitchSideEffect"] = 33] = "SwitchSideEffect";
     RuleId[RuleId["PrincessLithaEffect"] = 103] = "PrincessLithaEffect";
-    RuleId[RuleId["AbiSnakeCharmerEffect"] = 204] = "AbiSnakeCharmerEffect";
     RuleId[RuleId["WindWrathEffect"] = 215] = "WindWrathEffect";
     RuleId[RuleId["CavernSkulkerEffect"] = 302] = "CavernSkulkerEffect";
     RuleId[RuleId["DoomEffect"] = 315] = "DoomEffect";
+    RuleId[RuleId["CopyPlayEffect"] = 503] = "CopyPlayEffect";
+    RuleId[RuleId["EmpressSamaEffect"] = 509] = "EmpressSamaEffect";
+    RuleId[RuleId["LotusMuseEffect"] = 510] = "LotusMuseEffect";
+    RuleId[RuleId["AzureDragonsPeaceEffect"] = 513] = "AzureDragonsPeaceEffect";
     RuleId[RuleId["CycleKeeperEffect"] = 409] = "CycleKeeperEffect";
     RuleId[RuleId["CaveInEffect"] = 413] = "CaveInEffect";
     RuleId[RuleId["EyeOfSkyEffect"] = 603] = "EyeOfSkyEffect";

package/dist/rules/StartPlayerTurnRule.js

@@ -5,6 +5,7 @@ import { LocationType } from '../material/LocationType';
 import { MaterialType } from '../material/MaterialType';
 import { OngoingEffectType } from '../material/OngoingEffect';
 import { Memory } from '../Memory';
+import { EffectsHelper } from './EffectsHelper';
 import { PlayerHelper } from './PlayerHelper';
 import { RuleId } from './RuleId';
 export class StartPlayerTurnRule extends PlayerTurnRule {
@@ -13,20 +14,34 @@ export class StartPlayerTurnRule extends PlayerTurnRule {
         this.memorize(Memory.CurrentPlayer, this.player);
         this.memorize(Memory.CardsPlayed, [], this.player);
         this.memorize(Memory.ActivatedCards, []);
-        if (!this.remind(Memory.OngoingEffects).some(e => e.type === OngoingEffectType.LockSuit)) {
+        const effectsHelper = new EffectsHelper(this.game);
+        if (effectsHelper.getActiveOngoingEffects(OngoingEffectType.LockSuit).length === 0) {
             this.forget(Memory.Suit);
         }
+        const keepActionCardEffect = effectsHelper.getActiveOngoingEffects(OngoingEffectType.KeepActionCard).find((e) => this.material(MaterialType.Card).getItem(e.cardIndex).location.player === this.player);
         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((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back })));
+        if (keepActionCardEffect && !keepActionCardEffect.targets && actionCards.length > 0) {
+            return [this.startPlayerTurn(RuleId.EmpressSamaEffect, this.player)];
+        }
+        const keptCard = keepActionCardEffect?.targets?.[0];
+        const toDiscard = keptCard !== undefined ? actionCards.index((index) => index !== keptCard) : actionCards;
+        moves.push(...toDiscard.moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back })));
+        if (keepActionCardEffect?.targets) {
+            this.memorize(Memory.OngoingEffects, (effects) => effects.map((e) => e.type === OngoingEffectType.KeepActionCard && e.cardIndex === keepActionCardEffect.cardIndex
+                ? { ...e, targets: undefined } : e));
+        }
         for (const cardRule of new PlayerHelper(this.game, this.player).cardRules) {
             cardRule.onPlayerTurnStart?.();
         }
         for (const cardRule of new PlayerHelper(this.game, this.nextPlayer).cardRules) {
             cardRule.onFoeTurnStart?.();
         }
+        this.memorize(Memory.OngoingEffects, (effects) => effects
+            .map((e) => e.turnsLeft !== undefined ? { ...e, turnsLeft: e.turnsLeft - 1 } : e)
+            .filter((e) => e.turnsLeft === undefined || e.turnsLeft > 0));
         const stunTokens = this.material(MaterialType.StunToken).location(LocationType.CardStunTokens);
         moves.push(...stunTokens.deleteItems(1));
         const pendingEffects = this.remind(Memory.PendingEffects);

package/dist/rules/StashPowerTokensEffectRule.js

@@ -6,7 +6,7 @@ export class StashPowerTokensEffectRule extends EffectRule {
         const count = this.cardRule.getStashPowerTokenCount?.() ?? 1;
         return [
             this.material(MaterialType.PowerToken).createItem({
-                location: { type: LocationType.PlayerStash, player: this.player },
+                location: { type: LocationType.PlayerStash, player: this.cardRule.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 foeCrystals = this.material(MaterialType.Crystal).location(LocationType.PlayerCrystals).player(this.nextPlayer);
+        const foeCrystals = this.material(MaterialType.Crystal).location(LocationType.PlayerCrystals).player(this.cardRule.foe);
         if (foeCrystals.length > 0) {
-            moves.unshift(foeCrystals.moveItem({ type: LocationType.PlayerCrystals, player: this.player }));
+            moves.unshift(foeCrystals.moveItem({ type: LocationType.PlayerCrystals, player: this.cardRule.player }));
         }
         return moves;
     }

package/dist/rules/SwitchSideEffectRule.d.ts

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

package/dist/rules/SwitchSideEffectRule.js

@@ -4,12 +4,8 @@ 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) {
+        if (!this.getTargets().length) {
             return this.endEffect();
         }
         return [];
@@ -22,7 +18,7 @@ export class SwitchSideEffectRule extends EffectRule {
         }));
     }
     getTargets() {
-        return this.cardRule.getSwitchSideTargets();
+        return this.cardRule.getSwitchSideTargets?.() ?? this.material(MaterialType.Card).location(LocationType.PlayArea);
     }
     afterItemMove(move) {
         if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayArea) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/skyrift",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "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.5.0",
+    "@gamepark/rules-api": "~7.5.1",
     "es-toolkit": "^1.43.0",
     "vitest": "^4.0.15"
   },
-  "gitHead": "78e16066c5404fd72217e96816b3d8e9396e9993"
+  "gitHead": "ae6f1204deb145c936b165e0968ce50f79fe8645"
 }