@gamepark/skyrift 0.4.3 → 0.6.0

package/dist/rules/StartPlayerTurnRule.js

@@ -3,7 +3,9 @@ import { cardProperties } from '../material/CardProperties';
 import { CardType } from '../material/CardType';
 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 {
@@ -12,18 +14,34 @@ export class StartPlayerTurnRule extends PlayerTurnRule {
         this.memorize(Memory.CurrentPlayer, this.player);
         this.memorize(Memory.CardsPlayed, [], this.player);
         this.memorize(Memory.ActivatedCards, []);
-        this.forget(Memory.Suit);
+        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.4.3",
+  "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": "3ba3141e89e6204dd3acf7351054af00ec9ee46d"
+  "gitHead": "ae6f1204deb145c936b165e0968ce50f79fe8645"
 }