@gamepark/skyrift 0.1.0

package/dist/rules/StartPlayerTurnRule.js

@@ -0,0 +1,42 @@
+import { PlayerTurnRule } 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 { PlayerHelper } from './PlayerHelper';
+import { RuleId } from './RuleId';
+export class StartPlayerTurnRule extends PlayerTurnRule {
+    onRuleStart() {
+        const moves = [];
+        this.memorize(Memory.CurrentPlayer, this.player);
+        this.memorize(Memory.CardsPlayed, [], this.player);
+        this.memorize(Memory.OncePerTurnEffects, []);
+        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 }));
+        for (const cardRule of new PlayerHelper(this.game, this.player).cardRules) {
+            if (!cardRule.isStunned()) {
+                moves.push(...cardRule.onPlayerTurnStart(this.player));
+            }
+        }
+        for (const cardRule of new PlayerHelper(this.game, this.nextPlayer).cardRules) {
+            if (!cardRule.isStunned()) {
+                moves.push(...cardRule.onPlayerTurnStart(this.player));
+            }
+        }
+        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());
+        }
+        else {
+            moves.push(this.startRule(RuleId.PlayCard));
+        }
+        return moves;
+    }
+}

package/dist/rules/StartRoundRule.d.ts

@@ -0,0 +1,5 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleId } from './RuleId';
+export declare class StartRoundRule extends PlayerTurnRule {
+    onRuleStart(): (import("@gamepark/rules-api").CreateItem<number, number, number> | import("@gamepark/rules-api").StartRule<RuleId.StartPlayerTurn>)[];
+}

package/dist/rules/StartRoundRule.js

@@ -0,0 +1,12 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { RuleId } from './RuleId';
+export class StartRoundRule extends PlayerTurnRule {
+    onRuleStart() {
+        return [
+            this.material(MaterialType.Crystal).createItem({ location: { type: LocationType.Stake } }),
+            this.startRule(RuleId.StartPlayerTurn)
+        ];
+    }
+}

package/dist/rules/StashPowerTokenEffectRule.d.ts

@@ -0,0 +1,6 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from './EffectRule';
+export declare class StashPowerTokenEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+    getStashCount(): number;
+}

package/dist/rules/StashPowerTokenEffectRule.js

@@ -0,0 +1,20 @@
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { EffectRule } from './EffectRule';
+export class StashPowerTokenEffectRule extends EffectRule {
+    onRuleStart() {
+        const moves = [];
+        const stashCount = this.getStashCount();
+        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;
+    }
+    getStashCount() {
+        return 1;
+    }
+}

package/dist/rules/StealCrystalEffectRule.d.ts

@@ -0,0 +1,5 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from './EffectRule';
+export declare class StealCrystalEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+}

package/dist/rules/StealCrystalEffectRule.js

@@ -0,0 +1,13 @@
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+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 }));
+        }
+        return moves;
+    }
+}

package/dist/rules/StunCardRule.d.ts

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

package/dist/rules/StunCardRule.js

@@ -0,0 +1,40 @@
+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 { EffectRule } from './EffectRule';
+export class StunCardRule extends EffectRule {
+    stunCount = 1;
+    onRuleStart() {
+        if (!this.getTargets().length) {
+            return this.endEffect();
+        }
+        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;
+    }
+    getTargets() {
+        return this.material(MaterialType.Card)
+            .location(LocationType.PlayArea)
+            .id((id) => cardProperties[id.front].type === CardType.Creature);
+    }
+    afterItemMove(move) {
+        if (isCreateItemType(MaterialType.StunToken)(move) && move.item.location.type === LocationType.CardStunTokens) {
+            return this.endEffect();
+        }
+        return [];
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@gamepark/skyrift",
+  "version": "0.1.0",
+  "description": "The rules of SkyRift adapted for Game Park",
+  "sideEffects": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "Romain Fromi <romain@game-park.com> (https://game-park.com/)",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest",
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "publish": "lerna publish",
+    "lint": "eslint --fix"
+  },
+  "peerDependencies": {
+    "@gamepark/rules-api": ">=7",
+    "es-toolkit": "^1.39.10"
+  },
+  "devDependencies": {
+    "@gamepark/rules-api": "~7.2.0",
+    "es-toolkit": "^1.43.0",
+    "vitest": "^4.0.15"
+  }
+}