@gamepark/skyrift 0.4.0 → 0.4.2

package/dist/SkyriftRules.d.ts

@@ -27,7 +27,7 @@ import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
 import { StartRoundRule } from './rules/StartRoundRule';
 import { StashPowerTokensEffectRule } from './rules/StashPowerTokensEffectRule';
 import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
-import { StunCardRule } from './rules/StunCardRule';
+import { StunEffectRule } from './rules/StunEffectRule';
 export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType, LocationType> implements TimeLimit<MaterialGame<Deck, MaterialType, LocationType>, MaterialMove<Deck, MaterialType, LocationType>, Deck> {
     rules: {
         1: typeof StartRoundRule;
@@ -41,7 +41,7 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
         22: typeof DrawEffectRule;
         23: typeof DiscardEffectRule;
         24: typeof DestroyEffectRule;
-        25: typeof StunCardRule;
+        25: typeof StunEffectRule;
         26: typeof ReturnCardEffectRule;
         27: typeof PutPowerTokenEffectRule;
         28: typeof StashPowerTokensEffectRule;

package/dist/SkyriftRules.js

@@ -30,7 +30,7 @@ import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
 import { StartRoundRule } from './rules/StartRoundRule';
 import { StashPowerTokensEffectRule } from './rules/StashPowerTokensEffectRule';
 import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
-import { StunCardRule } from './rules/StunCardRule';
+import { StunEffectRule } from './rules/StunEffectRule';
 export class SkyriftRules extends SecretMaterialRules {
     rules = {
         [RuleId.StartRound]: StartRoundRule,
@@ -44,7 +44,7 @@ export class SkyriftRules extends SecretMaterialRules {
         [RuleId.DrawEffect]: DrawEffectRule,
         [RuleId.DiscardEffect]: DiscardEffectRule,
         [RuleId.DestroyEffect]: DestroyEffectRule,
-        [RuleId.StunEffect]: StunCardRule,
+        [RuleId.StunEffect]: StunEffectRule,
         [RuleId.ReturnCardEffect]: ReturnCardEffectRule,
         [RuleId.PutPowerTokensEffect]: PutPowerTokenEffectRule,
         [RuleId.StashPowerTokensEffect]: StashPowerTokensEffectRule,

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

@@ -14,7 +14,7 @@ class CallOfTheEclipseRule extends CardRule {
         return this.material(MaterialType.Card)
             .location(LocationType.PlayerHand)
             .player(this.player)
-            .id((id) => cardProperties[id.front].suit === CardSuit.Night);
+            .id((id) => id.front !== undefined && cardProperties[id.front].suit === CardSuit.Night);
     }
     isPlayCardOptional() {
         return true;

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

@@ -1,13 +1,9 @@
-import { Material } from '@gamepark/rules-api';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-import { DestroyEffect } from '../../EffectTraits';
-declare class DoomRule extends CardRule implements DestroyEffect {
+declare class DoomRule extends CardRule {
     onEnters(): void;
     onLeaves(): import("@gamepark/rules-api").MaterialMove[];
-    getDestroyTargets(): Material;
-    isAutoDestroy(): boolean;
 }
 export declare const Doom: {
     power: number;

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

@@ -10,15 +10,9 @@ class DoomRule extends CardRule {
         this.addPendingEffect(RuleId.DoomEffect);
     }
     onLeaves() {
-        this.addPendingEffect(RuleId.DestroyEffect);
-        return super.onLeaves();
-    }
-    getDestroyTargets() {
         const doomTokens = this.material(MaterialType.SpecialToken).id(SpecialTokenType.Doom).location(LocationType.CardSpecialTokens);
-        return this.playArea.index((index) => doomTokens.parent(index).length > 0);
-    }
-    isAutoDestroy() {
-        return true;
+        const doomedIndexes = doomTokens.getItems().map((item) => item.location.parent);
+        return [...this.playArea.index(doomedIndexes).moveItems((item) => ({ type: LocationType.PlayerDiscard, player: item.id.back })), ...super.onLeaves()];
     }
 }
 export const Doom = {

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

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

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

@@ -7,6 +7,10 @@ export class ArmadaEffectRule extends DiscardEffectRule {
         moves.push(this.customMove(CustomMoveType.Pass));
         return moves;
     }
+    onRuleStart() {
+        this.memorize(Memory.EffectCount, 0);
+        return [];
+    }
     onDiscard() {
         this.memorize(Memory.EffectCount, (count) => count + 1);
         return [];

package/dist/rules/DiscardEffectRule.js

@@ -8,14 +8,15 @@ export class DiscardEffectRule extends EffectRule {
         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() {
@@ -34,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/skyrift",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "The rules of SkyRift adapted for Game Park",
   "sideEffects": false,
   "type": "module",
@@ -30,5 +30,5 @@
     "es-toolkit": "^1.43.0",
     "vitest": "^4.0.15"
   },
-  "gitHead": "ec3b43325a7424c3279b61755343aac4845c39bc"
+  "gitHead": "0db12bff770ff3816b402b8eb7151a34c32947f7"
 }