src/samples/slay-the-spire-like/index.ts

@@ -3,6 +3,5 @@ export * from "./system/deck";
 export * from "./system/encounter";
 export * from "./system/grid-inventory";
 export * from "./system/map";
-export * from "./system/utils";
+export * from "./system/utils/parse-shape";
 export * from "./system/types";
-export { default as data } from "./data";

src/samples/slay-the-spire-like/system/deck/index.ts

@@ -1,2 +1,7 @@
-export * from "./factory";
+export type { GameCard, GameCardMeta, PlayerDeck, DeckRegions } from './types';
-export * from "./types";
+export {
+    generateDeckFromInventory,
+    createCard,
+    createPlayerDeck,
+    generateCardId,
+} from './factory';

src/samples/slay-the-spire-like/system/grid-inventory/index.ts

@@ -1,3 +1,24 @@
-export * from "./types";
+export type {
-export * from "./transform";
+  CellCoordinate,
+  CellKey,
+  GridInventory,
+  InventoryItem,
+  MutationResult,
+  PlacementResult,
+} from "./types";
+export type { GameItemMeta, GameItem } from "./types";
+
+export {
+  createGridInventory,
+  flipItem,
+  getAdjacentItems,
+  getItemAtCell,
+  getOccupiedCellSet,
+  moveItem,
+  placeItem,
+  removeItem,
+  rotateItem,
+  validatePlacement,
+} from "./transform";
+
 export * from "./factory";

src/samples/slay-the-spire-like/system/grid-inventory/transform.ts

@@ -1,4 +1,3 @@
-import { EffectData } from "../types";
 import type { ParsedShape } from "../utils/parse-shape";
 import type { Transform2D } from "../utils/shape-collision";
 import {
@@ -11,7 +10,6 @@ import {
 } from "../utils/shape-collision";
 import type {
   CellKey,
-  GameItemMeta,
   GridInventory,
   InventoryItem,
   MutationResult,
@@ -257,21 +255,3 @@ export function getAdjacentItems<TMeta>(
 
   return adjacent;
 }
-
-// export type EffectTable = Record<string, { data: EffectData; stacks: number }>;
-export function getItemEffects(inv: GridInventory<GameItemMeta>) {
-  const effects = {} as Record<
-    string,
-    Record<string, { data: EffectData; stacks: number }>
-  >;
-
-  for (const item of inv.items.values()) {
-    if (!item.meta) continue;
-    const { startEffects } = item.meta;
-    if (!startEffects) continue;
-
-    effects[item.id] = startEffects;
-  }
-
-  return effects;
-}

src/samples/slay-the-spire-like/system/grid-inventory/types.ts

@@ -1,4 +1,4 @@
-import { EffectData, ItemData } from "../types";
+import { ItemData } from "../types";
 import type { ParsedShape } from "../utils/parse-shape";
 import type { Transform2D } from "../utils/shape-collision";
 
@@ -64,7 +64,7 @@ export interface GameItemMeta {
   itemData: ItemData;
   shape: ParsedShape;
   consumedUses?: number;
-  startEffects?: Record<string, { data: EffectData; stacks: number }>;
+  startEffects?: Record<string, number>;
   tradePrice?: number;
 }
 export type GameItem = InventoryItem<GameItemMeta>;

src/samples/slay-the-spire-like/system/map/index.ts

@@ -1,3 +1,24 @@
-export * from "./generator";
+export { MapNodeType, MapLayerType } from "./types";
-export * from "./navigation";
+export type {
-export * from "./types";
+  MapNode,
+  MapLayer,
+  PointCrawlMap,
+  MapGenerationConfig,
+} from "./types";
+
+export { generatePointCrawlMap } from "./generator";
+export {
+  getNode,
+  getChildren,
+  getParents,
+  hasPath,
+  findAllPaths,
+} from "./generator";
+
+export {
+  canMoveTo,
+  moveToNode,
+  getReachableChildren,
+  isAtEndNode,
+  isAtStartNode,
+} from "./navigation";

src/samples/slay-the-spire-like/system/utils/index.ts

@@ -1,2 +0,0 @@
-export * from "./parse-shape";
-export * from "./shape-collision";

src/samples/slay-the-spire-like/system/utils/shape-collision.ts

@@ -1,4 +1,4 @@
-import type { ParsedShape } from "./parse-shape";
+import type { ParsedShape } from './parse-shape';
 
 /**
  * Represents a 2D point in grid coordinates.
@@ -54,7 +54,7 @@ export function transformPoint(
     point: Point2D,
     transform: Transform2D,
     shapeWidth: number,
-  shapeHeight: number,
+    shapeHeight: number
 ): Point2D {
     let { x, y } = point;
 
@@ -96,13 +96,10 @@ export function transformPoint(
 /**
  * Transforms a shape and returnss its occupied cells in world coordinates.
  */
-export function transformShape(
+export function transformShape(shape: ParsedShape, transform: Transform2D): Point2D[] {
-  shape: ParsedShape,
-  transform: Transform2D,
-): Point2D[] {
     const cells = getOccupiedCells(shape);
-  return cells.map((cell) =>
+    return cells.map(cell =>
-    transformPoint(cell, transform, shape.width, shape.height),
+        transformPoint(cell, transform, shape.width, shape.height)
     );
 }
 
@@ -113,12 +110,12 @@ export function checkCollision(
     shapeA: ParsedShape,
     transformA: Transform2D,
     shapeB: ParsedShape,
-  transformB: Transform2D,
+    transformB: Transform2D
 ): boolean {
     const cellsA = transformShape(shapeA, transformA);
     const cellsB = transformShape(shapeB, transformB);
 
-  const setA = new Set(cellsA.map((c) => `${c.x},${c.y}`));
+    const setA = new Set(cellsA.map(c => `${c.x},${c.y}`));
 
     for (const cell of cellsB) {
         if (setA.has(`${cell.x},${cell.y}`)) {
@@ -138,7 +135,7 @@ export function checkCollision(
 export function checkBoardCollision(
     shape: ParsedShape,
     transform: Transform2D,
-  occupiedCells: Set<string>,
+    occupiedCells: Set<string>
 ): boolean {
     const cells = transformShape(shape, transform);
 
@@ -162,17 +159,12 @@ export function checkBounds(
     shape: ParsedShape,
     transform: Transform2D,
     boardWidth: number,
-  boardHeight: number,
+    boardHeight: number
 ): boolean {
     const cells = transformShape(shape, transform);
 
     for (const cell of cells) {
-    if (
+        if (cell.x < 0 || cell.x >= boardWidth || cell.y < 0 || cell.y >= boardHeight) {
-      cell.x < 0 ||
-      cell.x >= boardWidth ||
-      cell.y < 0 ||
-      cell.y >= boardHeight
-    ) {
             return false;
         }
     }
@@ -184,19 +176,19 @@ export function checkBounds(
  * Validates that a placement is both in bounds and collision-free.
  * @returns Object with `valid` flag and optional `reason` string
  */
-export function validateShapePlacement(
+export function validatePlacement(
     shape: ParsedShape,
     transform: Transform2D,
     boardWidth: number,
     boardHeight: number,
-  occupiedCells: Set<string>,
+    occupiedCells: Set<string>
 ): { valid: true } | { valid: false; reason: string } {
     if (!checkBounds(shape, transform, boardWidth, boardHeight)) {
-    return { valid: false, reason: "超出边界" };
+        return { valid: false, reason: '超出边界' };
     }
 
     if (checkBoardCollision(shape, transform, occupiedCells)) {
-    return { valid: false, reason: "与已有形状重叠" };
+        return { valid: false, reason: '与已有形状重叠' };
     }
 
     return { valid: true };
@@ -207,13 +199,10 @@ export function validateShapePlacement(
  * @param current The current transform
  * @param degrees Degrees to rotate (typically 90, 180, or 270)
  */
-export function rotateTransform(
+export function rotateTransform(current: Transform2D, degrees: number): Transform2D {
-  current: Transform2D,
-  degrees: number,
-): Transform2D {
     return {
         ...current,
-    rotation: (((current.rotation + degrees) % 360) + 360) % 360,
+        rotation: ((current.rotation + degrees) % 360 + 360) % 360,
     };
 }
 

tests/samples/slay-the-spire-like/utils/shape-utils.test.ts

@@ -1,18 +1,18 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
-import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
+import { parseShapeString } from '@/samples/slay-the-spire-like/system/utils/parse-shape';
 import {
     checkCollision,
     checkBoardCollision,
     checkBounds,
-  validateShapePlacement,
+    validatePlacement,
     transformShape,
     getOccupiedCells,
     IDENTITY_TRANSFORM,
-} from "@/samples/slay-the-spire-like/system/utils/shape-collision";
+} from '@/samples/slay-the-spire-like/system/utils/shape-collision';
 
-describe("parseShapeString", () => {
+describe('parseShapeString', () => {
-  it("should parse a single cell with o", () => {
+    it('should parse a single cell with o', () => {
-    const result = parseShapeString("o");
+        const result = parseShapeString('o');
         expect(result.grid).toEqual([[true]]);
         expect(result.width).toBe(1);
         expect(result.height).toBe(1);
@@ -21,8 +21,8 @@ describe("parseShapeString", () => {
         expect(result.originY).toBe(0);
     });
 
-  it("should parse a horizontal line", () => {
+    it('should parse a horizontal line', () => {
-    const result = parseShapeString("oee");
+        const result = parseShapeString('oee');
         expect(result.width).toBe(3);
         expect(result.height).toBe(1);
         expect(result.count).toBe(3);
@@ -31,8 +31,8 @@ describe("parseShapeString", () => {
         expect(result.originY).toBe(0);
     });
 
-  it("should parse a vertical line", () => {
+    it('should parse a vertical line', () => {
-    const result = parseShapeString("oss");
+        const result = parseShapeString('oss');
         expect(result.width).toBe(1);
         expect(result.height).toBe(3);
         expect(result.count).toBe(3);
@@ -41,8 +41,8 @@ describe("parseShapeString", () => {
         expect(result.originY).toBe(0);
     });
 
-  it("should parse an L shape", () => {
+    it('should parse an L shape', () => {
-    const result = parseShapeString("oes");
+        const result = parseShapeString('oes');
         expect(result.width).toBe(2);
         expect(result.height).toBe(2);
         expect(result.count).toBe(3);
@@ -52,47 +52,47 @@ describe("parseShapeString", () => {
         ]);
     });
 
-  it("should handle return command", () => {
+    it('should handle return command', () => {
-    const result = parseShapeString("oeerww");
+        const result = parseShapeString('oeerww');
         expect(result.width).toBe(4);
         expect(result.height).toBe(1);
         expect(result.count).toBe(4);
         expect(result.grid).toEqual([[true, true, true, true]]);
     });
 
-  it("should handle case insensitivity", () => {
+    it('should handle case insensitivity', () => {
-    const resultLower = parseShapeString("oes");
+        const resultLower = parseShapeString('oes');
-    const resultUpper = parseShapeString("OES");
+        const resultUpper = parseShapeString('OES');
         expect(resultLower.grid).toEqual(resultUpper.grid);
         expect(resultLower.count).toBe(resultUpper.count);
     });
 
-  it("should return empty grid for empty input", () => {
+    it('should return empty grid for empty input', () => {
-    const result = parseShapeString("");
+        const result = parseShapeString('');
         expect(result.grid).toEqual([[]]);
         expect(result.width).toBe(0);
         expect(result.height).toBe(1);
         expect(result.count).toBe(0);
     });
 
-  it("should track origin correctly", () => {
+    it('should track origin correctly', () => {
         // eeso: e(1,0), e(2,0), s(2,1), o sets origin at (2,1)
         // After normalization: minX=1, minY=0, so originX = 2-1 = 1, originY = 1-0 = 1
-    const result = parseShapeString("eeso");
+        const result = parseShapeString('eeso');
         expect(result.originX).toBe(1);
         expect(result.originY).toBe(1);
     });
 
-  it("should track origin at first o only", () => {
+    it('should track origin at first o only', () => {
-    const result = parseShapeString("oes");
+        const result = parseShapeString('oes');
         expect(result.originX).toBe(0);
         expect(result.originY).toBe(0);
     });
 
-  it("should handle complex T shape", () => {
+    it('should handle complex T shape', () => {
         // oewers: o(0,0), e(1,0), w(0,0), e(1,0), r->(0,0), s(0,1)
         // Filled: (0,0), (1,0), (0,1) - 3 cells
-    const result = parseShapeString("oewers");
+        const result = parseShapeString('oewers');
         expect(result.width).toBe(2);
         expect(result.height).toBe(2);
         expect(result.count).toBe(3);
@@ -103,16 +103,16 @@ describe("parseShapeString", () => {
     });
 });
 
-describe("shape-collision", () => {
+describe('shape-collision', () => {
-  describe("getOccupiedCells", () => {
+    describe('getOccupiedCells', () => {
-    it("should return cells for a single cell shape", () => {
+        it('should return cells for a single cell shape', () => {
-      const shape = parseShapeString("o");
+            const shape = parseShapeString('o');
             const cells = getOccupiedCells(shape);
             expect(cells).toEqual([{ x: 0, y: 0 }]);
         });
 
-    it("should return cells for a horizontal line", () => {
+        it('should return cells for a horizontal line', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
             const cells = getOccupiedCells(shape);
             expect(cells).toEqual([
                 { x: 0, y: 0 },
@@ -120,8 +120,8 @@ describe("shape-collision", () => {
             ]);
         });
 
-    it("should return cells for an L shape", () => {
+        it('should return cells for an L shape', () => {
-      const shape = parseShapeString("oes");
+            const shape = parseShapeString('oes');
             const cells = getOccupiedCells(shape);
             expect(cells).toEqual([
                 { x: 0, y: 0 },
@@ -131,49 +131,49 @@ describe("shape-collision", () => {
         });
     });
 
-  describe("checkCollision", () => {
+    describe('checkCollision', () => {
-    it("should detect collision between overlapping shapes", () => {
+        it('should detect collision between overlapping shapes', () => {
-      const shapeA = parseShapeString("o");
+            const shapeA = parseShapeString('o');
-      const shapeB = parseShapeString("o");
+            const shapeB = parseShapeString('o');
 
             const result = checkCollision(
                 shapeA,
                 { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                 shapeB,
-        { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
+                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } }
             );
             expect(result).toBe(true);
         });
 
-    it("should not detect collision between non-overlapping shapes", () => {
+        it('should not detect collision between non-overlapping shapes', () => {
-      const shapeA = parseShapeString("o");
+            const shapeA = parseShapeString('o');
-      const shapeB = parseShapeString("o");
+            const shapeB = parseShapeString('o');
 
             const result = checkCollision(
                 shapeA,
                 { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                 shapeB,
-        { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } },
+                { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } }
             );
             expect(result).toBe(false);
         });
 
-    it("should detect collision with adjacent shapes", () => {
+        it('should detect collision with adjacent shapes', () => {
-      const shapeA = parseShapeString("o");
+            const shapeA = parseShapeString('o');
-      const shapeB = parseShapeString("o");
+            const shapeB = parseShapeString('o');
 
             const result = checkCollision(
                 shapeA,
                 { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                 shapeB,
-        { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } },
+                { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } }
             );
             expect(result).toBe(false);
         });
 
-    it("should detect collision with rotation", () => {
+        it('should detect collision with rotation', () => {
-      const shapeA = parseShapeString("oe");
+            const shapeA = parseShapeString('oe');
-      const shapeB = parseShapeString("os");
+            const shapeB = parseShapeString('os');
 
             // shapeA is horizontal at (0,0)-(1,0)
             // shapeB rotated 90° becomes vertical at (0,0)-(0,1)
@@ -182,142 +182,130 @@ describe("shape-collision", () => {
                 shapeA,
                 { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                 shapeB,
-        { ...IDENTITY_TRANSFORM, rotation: 90, offset: { x: 0, y: 0 } },
+                { ...IDENTITY_TRANSFORM, rotation: 90, offset: { x: 0, y: 0 } }
             );
             expect(result).toBe(true);
         });
     });
 
-  describe("checkBoardCollision", () => {
+    describe('checkBoardCollision', () => {
-    it("should detect collision with occupied cells", () => {
+        it('should detect collision with occupied cells', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
-      const occupied = new Set(["0,0", "1,0"]);
+            const occupied = new Set(['0,0', '1,0']);
 
             const result = checkBoardCollision(shape, IDENTITY_TRANSFORM, occupied);
             expect(result).toBe(true);
         });
 
-    it("should not detect collision with empty board", () => {
+        it('should not detect collision with empty board', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
             const occupied = new Set<string>();
 
             const result = checkBoardCollision(shape, IDENTITY_TRANSFORM, occupied);
             expect(result).toBe(false);
         });
 
-    it("should detect collision after translation", () => {
+        it('should detect collision after translation', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
-      const occupied = new Set(["5,5", "6,5"]);
+            const occupied = new Set(['5,5', '6,5']);
 
             const result = checkBoardCollision(
                 shape,
                 { ...IDENTITY_TRANSFORM, offset: { x: 5, y: 5 } },
-        occupied,
+                occupied
             );
             expect(result).toBe(true);
         });
     });
 
-  describe("checkBounds", () => {
+    describe('checkBounds', () => {
-    it("should return true for shape within bounds", () => {
+        it('should return true for shape within bounds', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
 
             const result = checkBounds(shape, IDENTITY_TRANSFORM, 10, 10);
             expect(result).toBe(true);
         });
 
-    it("should return false for shape outside bounds", () => {
+        it('should return false for shape outside bounds', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
 
             const result = checkBounds(
                 shape,
                 { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 0 } },
                 10,
-        10,
+                10
             );
             expect(result).toBe(false);
         });
 
-    it("should return false for negative coordinates", () => {
+        it('should return false for negative coordinates', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
 
             const result = checkBounds(
                 shape,
                 { ...IDENTITY_TRANSFORM, offset: { x: -1, y: 0 } },
                 10,
-        10,
+                10
             );
             expect(result).toBe(false);
         });
 
-    it("should return true for shape at boundary edge", () => {
+        it('should return true for shape at boundary edge', () => {
-      const shape = parseShapeString("o");
+            const shape = parseShapeString('o');
 
             const result = checkBounds(
                 shape,
                 { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 9 } },
                 10,
-        10,
+                10
             );
             expect(result).toBe(true);
         });
     });
 
-  describe("validatePlacement", () => {
+    describe('validatePlacement', () => {
-    it("should return valid for good placement", () => {
+        it('should return valid for good placement', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
             const occupied = new Set<string>();
 
-      const result = validateShapePlacement(
+            const result = validatePlacement(shape, IDENTITY_TRANSFORM, 10, 10, occupied);
-        shape,
-        IDENTITY_TRANSFORM,
-        10,
-        10,
-        occupied,
-      );
             expect(result).toEqual({ valid: true });
         });
 
-    it("should return invalid for out of bounds", () => {
+        it('should return invalid for out of bounds', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
             const occupied = new Set<string>();
 
-      const result = validateShapePlacement(
+            const result = validatePlacement(
                 shape,
                 { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 0 } },
                 10,
                 10,
-        occupied,
+                occupied
             );
-      expect(result).toEqual({ valid: false, reason: "超出边界" });
+            expect(result).toEqual({ valid: false, reason: '超出边界' });
         });
 
-    it("should return invalid for collision", () => {
+        it('should return invalid for collision', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
-      const occupied = new Set(["0,0", "1,0"]);
+            const occupied = new Set(['0,0', '1,0']);
 
-      const result = validateShapePlacement(
+            const result = validatePlacement(shape, IDENTITY_TRANSFORM, 10, 10, occupied);
-        shape,
+            expect(result).toEqual({ valid: false, reason: '与已有形状重叠' });
-        IDENTITY_TRANSFORM,
-        10,
-        10,
-        occupied,
-      );
-      expect(result).toEqual({ valid: false, reason: "与已有形状重叠" });
         });
     });
 
-  describe("transformShape", () => {
+    describe('transformShape', () => {
-    it("should apply translation correctly", () => {
+        it('should apply translation correctly', () => {
-      const shape = parseShapeString("o");
+            const shape = parseShapeString('o');
             const transform = { ...IDENTITY_TRANSFORM, offset: { x: 5, y: 3 } };
 
             const cells = transformShape(shape, transform);
             expect(cells).toEqual([{ x: 5, y: 3 }]);
         });
 
-    it("should apply 90° rotation correctly", () => {
+        it('should apply 90° rotation correctly', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
             const transform = { ...IDENTITY_TRANSFORM, rotation: 90 };
 
             const cells = transformShape(shape, transform);
@@ -327,8 +315,8 @@ describe("shape-collision", () => {
             ]);
         });
 
-    it("should apply horizontal flip correctly", () => {
+        it('should apply horizontal flip correctly', () => {
-      const shape = parseShapeString("oe");
+            const shape = parseShapeString('oe');
             const transform = { ...IDENTITY_TRANSFORM, flipX: true };
 
             const cells = transformShape(shape, transform);
@@ -338,8 +326,8 @@ describe("shape-collision", () => {
             ]);
         });
 
-    it("should apply vertical flip correctly", () => {
+        it('should apply vertical flip correctly', () => {
-      const shape = parseShapeString("os");
+            const shape = parseShapeString('os');
             const transform = { ...IDENTITY_TRANSFORM, flipY: true };
 
             const cells = transformShape(shape, transform);
@@ -349,8 +337,8 @@ describe("shape-collision", () => {
             ]);
         });
 
-    it("should combine rotation and translation", () => {
+        it('should combine rotation and translation', () => {
-      const shape = parseShapeString("os");
+            const shape = parseShapeString('os');
             const transform = {
                 ...IDENTITY_TRANSFORM,
                 rotation: 90,