hypercross
/
boardgame-core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: hypercross:34cb828f60e4a4d20bd2c93089e1fa99fb70406e
Branches Tags
hypercross:master
..
compare: hypercross:52b6cecd647a39ff8b52acb3f7fb708dad693c87
Branches Tags
hypercross:master

No commits in common. "34cb828f60e4a4d20bd2c93089e1fa99fb70406e" and "52b6cecd647a39ff8b52acb3f7fb708dad693c87" have entirely different histories.
34cb828f60 ... 52b6cecd64

13 changed files with 2996 additions and 3523 deletions
Show Stats Expand all files Collapse all files

6
src/samples/slay-the-spire-like/system/encounter/combat.ts
View File

@ -29,12 +29,6 @@ export function buildCombatState(
}; };
} }
export function buildCombatEncounterState(
data: EncounterData<"minion" | "elite">,
): CombatEncounterState {
return { data, blocked: false };
}
function createEnemyEntities(encounter: EncounterData): EnemyEntity[] { function createEnemyEntities(encounter: EncounterData): EnemyEntity[] {
const enemies: EnemyEntity[] = []; const enemies: EnemyEntity[] = [];
let instanceCounter = 0; let instanceCounter = 0;

100
src/samples/slay-the-spire-like/system/encounter/encounter.ts
View File

@ -1,100 +0,0 @@
import { createGridInventory, placeItem } from "../grid-inventory";
import { GameItemMeta } from "../grid-inventory/types";
import { IDENTITY_TRANSFORM } from "../utils/shape-collision";
import { parseShapeString } from "../utils/parse-shape";
import { EncounterData, EncounterType, ItemData } from "../types";
import type { RNG } from "@/utils/rng";
import type {
CampEncounterState,
CombatEncounterState,
CurioEncounterState,
DialogueEncounterState,
EncounterState,
ShopEncounterState,
} from "./types";
import { buildCombatEncounterState } from "./combat";
import { buildShopEncounterState } from "./shop";
function createCurioItems(allItems: ItemData[], rng: RNG): GameItemMeta[] {
const curioItems: GameItemMeta[] = [];
const rolledIndices = new Set<number>();
for (let i = 0; i < 3 && rolledIndices.size < allItems.length; i++) {
let index: number;
do {
index = rng.nextInt(allItems.length);
} while (rolledIndices.has(index));
rolledIndices.add(index);
const itemData = allItems[index];
const shape = parseShapeString(itemData.shape);
curioItems.push({ itemData, shape });
}
return curioItems;
}
export function buildCurioEncounterState(
data: EncounterData<"curio">,
allItems: ItemData[],
rng: RNG,
): CurioEncounterState {
const items = createCurioItems(allItems, rng);
const inventory = createGridInventory<GameItemMeta>(6, 4);
for (let i = 0; i < items.length; i++) {
const meta = items[i];
placeItem(inventory, {
id: `curio-item-${i}`,
shape: meta.shape,
transform: { ...IDENTITY_TRANSFORM, offset: { x: i, y: 0 } },
meta,
});
}
return { data, items: inventory };
}
export function buildCampEncounterState(
data: EncounterData<"camp">,
): CampEncounterState {
return { data };
}
export function buildDialogueEncounterState(
data: EncounterData<"event">,
): DialogueEncounterState {
return { data, blocked: false };
}
export function buildEncounterState(
data: EncounterData<EncounterType>,
allItems: ItemData[],
rng: RNG,
idCounter: { value: number },
): EncounterState {
switch (data.type) {
case "minion":
case "elite":
return buildCombatEncounterState(
data as EncounterData<"minion" | "elite">,
);
case "shop":
return buildShopEncounterState(
data as EncounterData<"shop">,
allItems,
rng,
idCounter,
);
case "curio":
return buildCurioEncounterState(
data as EncounterData<"curio">,
allItems,
rng,
);
case "camp":
return buildCampEncounterState(data as EncounterData<"camp">);
case "event":
return buildDialogueEncounterState(data as EncounterData<"event">);
}
}

5
src/samples/slay-the-spire-like/system/encounter/index.ts
View File

@ -1,4 +1,3 @@
export { buildCombatState, buildCombatEncounterState } from "./combat";
export { buildShopEncounterState, generateInstanceId } from "./shop";
export { buildEncounterState } from "./encounter";
export { RunState, EncounterState } from "./types"; export { RunState, EncounterState } from "./types";
export { buildCombatState } from "./combat";
export { generateInstanceId } from "./shop";

59
src/samples/slay-the-spire-like/system/encounter/shop.ts
View File

@ -1,63 +1,4 @@
import { createGridInventory, placeItem } from "../grid-inventory";
import { GameItemMeta } from "../grid-inventory/types";
import { IDENTITY_TRANSFORM } from "../utils/shape-collision";
import { parseShapeString } from "../utils/parse-shape";
import { EncounterData, ItemData } from "../types";
import type { RNG } from "@/utils/rng";
import type { ShopEncounterState } from "./types";
export function generateInstanceId(counter: { value: number }): string { export function generateInstanceId(counter: { value: number }): string {
counter.value++; counter.value++;
return `item-${counter.value}`; return `item-${counter.value}`;
} }
function createShopItems(
allItems: ItemData[],
rng: RNG,
): (GameItemMeta & { sellPrice: number })[] {
const shopItems: (GameItemMeta & { sellPrice: number })[] = [];
const rolledIndices = new Set<number>();
for (let i = 0; i < 5 && rolledIndices.size < allItems.length; i++) {
let index: number;
do {
index = rng.nextInt(allItems.length);
} while (rolledIndices.has(index));
rolledIndices.add(index);
const itemData = allItems[index];
const shape = parseShapeString(itemData.shape);
const sellPrice = Math.floor(
(rng.nextInt(5) + rng.nextInt(5) + 1) * 0.2 * itemData.price,
);
shopItems.push({ itemData, shape, sellPrice });
}
return shopItems;
}
export function buildShopEncounterState(
data: EncounterData<"shop">,
allItems: ItemData[],
rng: RNG,
idCounter: { value: number },
): ShopEncounterState {
const items = createShopItems(allItems, rng);
const inventory = createGridInventory<GameItemMeta & { sellPrice: number }>(
6,
4,
);
for (let i = 0; i < items.length; i++) {
const meta = items[i];
placeItem(inventory, {
id: generateInstanceId(idCounter),
shape: meta.shape,
transform: { ...IDENTITY_TRANSFORM, offset: { x: i, y: 0 } },
meta,
});
}
return { data, items: inventory };
}

141
src/samples/tic-tac-toe.ts
View File

@ -1,68 +1,32 @@
import { Part } from "@/core/part"; import {Part} from "boardgame-core";
import { createRegion } from "@/core/region"; import {createRegion} from "boardgame-core";
import { import {createGameCommandRegistry, createPromptDef, IGameContext} from "boardgame-core";
createGameCommandRegistry,
createPromptDef,
IGameContext,
} from "@/core/game";
const BOARD_SIZE = 3; const BOARD_SIZE = 3;
const MAX_TURNS = BOARD_SIZE * BOARD_SIZE; const MAX_TURNS = BOARD_SIZE * BOARD_SIZE;
const WINNING_LINES: number[][][] = [ const WINNING_LINES: number[][][] = [
[ [[0, 0], [0, 1], [0, 2]],
[0, 0], [[1, 0], [1, 1], [1, 2]],
[0, 1], [[2, 0], [2, 1], [2, 2]],
[0, 2], [[0, 0], [1, 0], [2, 0]],
], [[0, 1], [1, 1], [2, 1]],
[ [[0, 2], [1, 2], [2, 2]],
[1, 0], [[0, 0], [1, 1], [2, 2]],
[1, 1], [[0, 2], [1, 1], [2, 0]],
[1, 2],
],
[
[2, 0],
[2, 1],
[2, 2],
],
[
[0, 0],
[1, 0],
[2, 0],
],
[
[0, 1],
[1, 1],
[2, 1],
],
[
[0, 2],
[1, 2],
[2, 2],
],
[
[0, 0],
[1, 1],
[2, 2],
],
[
[0, 2],
[1, 1],
[2, 0],
],
]; ];
export type PlayerType = "X" | "O"; export type PlayerType = 'X' | 'O';
export type WinnerType = PlayerType | "draw" | null; export type WinnerType = PlayerType | 'draw' | null;
export type TicTacToePart = Part<{ player: PlayerType }>; export type TicTacToePart = Part<{ player: PlayerType }>;
export function createInitialState() { export function createInitialState() {
return { return {
board: createRegion("board", [ board: createRegion('board', [
{ name: "x", min: 0, max: BOARD_SIZE - 1 }, { name: 'x', min: 0, max: BOARD_SIZE - 1 },
{ name: "y", min: 0, max: BOARD_SIZE - 1 }, { name: 'y', min: 0, max: BOARD_SIZE - 1 },
]), ]),
parts: {} as Record<string, TicTacToePart>, parts: {} as Record<string, TicTacToePart>,
currentPlayer: "X" as PlayerType, currentPlayer: 'X' as PlayerType,
winner: null as WinnerType, winner: null as WinnerType,
turn: 0, turn: 0,
}; };
@ -72,9 +36,8 @@ export type TicTacToeGame = IGameContext<TicTacToeState>;
export const registry = createGameCommandRegistry<TicTacToeState>(); export const registry = createGameCommandRegistry<TicTacToeState>();
export const prompts = { export const prompts = {
play: createPromptDef<[PlayerType, number, number]>( play: createPromptDef<[PlayerType, number, number]>(
"play <player> <row:number> <col:number>", 'play <player> <row:number> <col:number>')
), }
};
export async function start(game: TicTacToeGame) { export async function start(game: TicTacToeGame) {
while (true) { while (true) {
@ -82,10 +45,10 @@ export async function start(game: TicTacToeGame) {
const turnNumber = game.value.turn + 1; const turnNumber = game.value.turn + 1;
const turnOutput = await turn(game, currentPlayer, turnNumber); const turnOutput = await turn(game, currentPlayer, turnNumber);
game.produce((state) => { game.produce(state => {
state.winner = turnOutput.winner; state.winner = turnOutput.winner;
if (!state.winner) { if (!state.winner) {
state.currentPlayer = state.currentPlayer === "X" ? "O" : "X"; state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
state.turn = turnNumber; state.turn = turnNumber;
} }
}); });
@ -96,9 +59,9 @@ export async function start(game: TicTacToeGame) {
} }
const turn = registry.register({ const turn = registry.register({
schema: "turn <player> <turnNumber:number>", schema: 'turn <player> <turnNumber:number>',
async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) { async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
const { player, row, col } = await game.prompt( const {player, row, col} = await game.prompt(
prompts.play, prompts.play,
(player, row, col) => { (player, row, col) => {
if (player !== turnPlayer) { if (player !== turnPlayer) {
@ -111,41 +74,32 @@ const turn = registry.register({
return { player, row, col }; return { player, row, col };
} }
}, },
game.value.currentPlayer, game.value.currentPlayer
); );
placePiece(game, row, col, turnPlayer); placePiece(game, row, col, turnPlayer);
const winner = checkWinner(game); const winner = checkWinner(game);
if (winner) return { winner }; if (winner) return { winner };
if (turnNumber >= MAX_TURNS) return { winner: "draw" as WinnerType }; if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
return { winner: null }; return { winner: null };
}, }
}); });
function isValidMove(row: number, col: number): boolean { function isValidMove(row: number, col: number): boolean {
return ( return !isNaN(row) && !isNaN(col) && row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;
!isNaN(row) &&
!isNaN(col) &&
row >= 0 &&
row < BOARD_SIZE &&
col >= 0 &&
col < BOARD_SIZE
);
} }
export function isCellOccupied( export function isCellOccupied(host: TicTacToeGame, row: number, col: number): boolean {
host: TicTacToeGame,
row: number,
col: number,
): boolean {
return !!host.value.board.partMap[`${row},${col}`]; return !!host.value.board.partMap[`${row},${col}`];
} }
export function hasWinningLine(positions: number[][]): boolean { export function hasWinningLine(positions: number[][]): boolean {
return WINNING_LINES.some((line) => return WINNING_LINES.some(line =>
line.every(([r, c]) => positions.some(([pr, pc]) => pr === r && pc === c)), line.every(([r, c]) =>
positions.some(([pr, pc]) => pr === r && pc === c)
)
); );
} }
@ -153,35 +107,24 @@ export function checkWinner(host: TicTacToeGame): WinnerType {
const parts = host.value.parts; const parts = host.value.parts;
const partsArray = Object.values(parts); const partsArray = Object.values(parts);
const xPositions = partsArray const xPositions = partsArray.filter((p: TicTacToePart) => p.player === 'X').map((p: TicTacToePart) => p.position);
.filter((p: TicTacToePart) => p.player === "X") const oPositions = partsArray.filter((p: TicTacToePart) => p.player === 'O').map((p: TicTacToePart) => p.position);
.map((p: TicTacToePart) => p.position);
const oPositions = partsArray
.filter((p: TicTacToePart) => p.player === "O")
.map((p: TicTacToePart) => p.position);
if (hasWinningLine(xPositions)) return "X"; if (hasWinningLine(xPositions)) return 'X';
if (hasWinningLine(oPositions)) return "O"; if (hasWinningLine(oPositions)) return 'O';
if (partsArray.length >= MAX_TURNS) return "draw"; if (partsArray.length >= MAX_TURNS) return 'draw';
return null; return null;
} }
export function placePiece( export function placePiece(host: TicTacToeGame, row: number, col: number, player: PlayerType) {
host: TicTacToeGame,
row: number,
col: number,
player: PlayerType,
) {
const board = host.value.board; const board = host.value.board;
const moveNumber = Object.keys(host.value.parts).length + 1; const moveNumber = Object.keys(host.value.parts).length + 1;
const piece: TicTacToePart = { const piece: TicTacToePart = {
regionId: "board", regionId: 'board', position: [row, col], player,
position: [row, col], id: `piece-${player}-${moveNumber}`
player, }
id: `piece-${player}-${moveNumber}`, host.produce(state => {
};
host.produce((state) => {
state.parts[piece.id] = piece; state.parts[piece.id] = piece;
board.childIds.push(piece.id); board.childIds.push(piece.id);
board.partMap[`${row},${col}`] = piece.id; board.partMap[`${row},${col}`] = piece.id;

335
tests/core/game-host.test.ts
View File

@ -1,84 +1,95 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { import {
registry, registry,
createInitialState, createInitialState,
start, start,
TicTacToeState, TicTacToeState,
} from "@/samples/tic-tac-toe"; WinnerType,
import { createGameHost, GameHost } from "@/core/game-host"; PlayerType
import type { PromptEvent } from "@/utils/command"; } from '@/samples/tic-tac-toe';
import { createGameHost, GameHost } from '@/core/game-host';
import type { PromptEvent } from '@/utils/command';
import { MutableSignal } from '@/utils/mutable-signal';
import {IGameContext} from "../../src";
type TestGameHost = GameHost<TicTacToeState> & {
_context: IGameContext<TicTacToeState>;
context: IGameContext<TicTacToeState>;
}
function createTestHost() { function createTestHost() {
const host = createGameHost({ registry, createInitialState, start }); const host: TestGameHost = createGameHost(
{ registry, createInitialState, start }
);
host.context = host._context;
return { host }; return { host };
} }
function waitForPromptEvent(host: GameHost<any>): Promise<PromptEvent> { function waitForPromptEvent(host: GameHost<any>): Promise<PromptEvent> {
return new Promise((resolve) => { return new Promise(resolve => {
// @ts-ignore - accessing private _context for testing host.context._commands.on('prompt', resolve);
host._context._commands.on("prompt", resolve);
}); });
} }
describe("GameHost", () => { describe('GameHost', () => {
describe("creation", () => { describe('creation', () => {
it("should create host with initial state", () => { it('should create host with initial state', () => {
const { host } = createTestHost(); const { host } = createTestHost();
expect(host.state.value.currentPlayer).toBe("X"); expect(host.context._state.value.currentPlayer).toBe('X');
expect(host.state.value.winner).toBeNull(); expect(host.context._state.value.winner).toBeNull();
expect(host.state.value.turn).toBe(0); expect(host.context._state.value.turn).toBe(0);
expect(Object.keys(host.state.value.parts).length).toBe(0); expect(Object.keys(host.context._state.value.parts).length).toBe(0);
}); });
it('should have status "created" by default', () => { it('should have status "created" by default', () => {
const { host } = createTestHost(); const { host } = createTestHost();
expect(host.status.value).toBe("created"); expect(host.status.value).toBe('created');
}); });
it("should have null activePromptSchema initially", () => { it('should have null activePromptSchema initially', () => {
const { host } = createTestHost(); const { host } = createTestHost();
expect(host.activePromptSchema.value).toBeNull(); expect(host.activePromptSchema.value).toBeNull();
}); });
}); });
describe("tryInput", () => { describe('tryInput', () => {
it('should return "No active prompt" when no prompt is active', () => { it('should return "No active prompt" when no prompt is active', () => {
const { host } = createTestHost(); const { host } = createTestHost();
const result = host.tryInput("play X 1 1"); const result = host.tryInput('play X 1 1');
expect(result).toBe("No active prompt"); expect(result).toBe('No active prompt');
}); });
it("should accept valid input when prompt is active", async () => { it('should accept valid input when prompt is active', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
const runPromise = host.start(); const runPromise = host.start();
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
expect(promptEvent.schema.name).toBe("play"); expect(promptEvent.schema.name).toBe('play');
expect(host.activePromptSchema.value?.name).toBe("play"); expect(host.activePromptSchema.value?.name).toBe('play');
const error = host.tryInput("play X 1 1"); const error = host.tryInput('play X 1 1');
expect(error).toBeNull(); expect(error).toBeNull();
// Cancel to end the game since start runs until game over // Cancel to end the game since start runs until game over
const nextPromptPromise = waitForPromptEvent(host); const nextPromptPromise = waitForPromptEvent(host);
const nextPrompt = await nextPromptPromise; const nextPrompt = await nextPromptPromise;
nextPrompt.cancel("test cleanup"); nextPrompt.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
}); });
it("should reject invalid input", async () => { it('should reject invalid input', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
@ -86,29 +97,29 @@ describe("GameHost", () => {
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
const error = host.tryInput("invalid command"); const error = host.tryInput('invalid command');
expect(error).not.toBeNull(); expect(error).not.toBeNull();
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
}); });
it("should return error when disposed", () => { it('should return error when disposed', () => {
const { host } = createTestHost(); const { host } = createTestHost();
host.dispose(); host.dispose();
const result = host.tryInput("play X 1 1"); const result = host.tryInput('play X 1 1');
expect(result).toBe("GameHost is disposed"); expect(result).toBe('GameHost is disposed');
}); });
}); });
describe("getActivePromptSchema", () => { describe('getActivePromptSchema', () => {
it("should return schema when prompt is active", async () => { it('should return schema when prompt is active', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
@ -118,26 +129,26 @@ describe("GameHost", () => {
const schema = host.activePromptSchema.value; const schema = host.activePromptSchema.value;
expect(schema).not.toBeNull(); expect(schema).not.toBeNull();
expect(schema?.name).toBe("play"); expect(schema?.name).toBe('play');
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
}); });
it("should return null when no prompt is active", () => { it('should return null when no prompt is active', () => {
const { host } = createTestHost(); const { host } = createTestHost();
expect(host.activePromptSchema.value).toBeNull(); expect(host.activePromptSchema.value).toBeNull();
}); });
}); });
describe("start", () => { describe('start', () => {
it("should reset state and run start command", async () => { it('should reset state and run start command', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
// First setup - make one move // First setup - make one move
@ -146,25 +157,20 @@ describe("GameHost", () => {
let promptEvent = await promptPromise; let promptEvent = await promptPromise;
// Make a move // Make a move
promptEvent.tryCommit({ promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
name: "play",
params: ["X", 1, 1],
options: {},
flags: {},
});
// Wait for next prompt (next turn) and cancel // Wait for next prompt (next turn) and cancel
promptPromise = waitForPromptEvent(host); promptPromise = waitForPromptEvent(host);
promptEvent = await promptPromise; promptEvent = await promptPromise;
promptEvent.cancel("test end"); promptEvent.cancel('test end');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test end"); expect(error.message).toBe('test end');
} }
expect(Object.keys(host.state.value.parts).length).toBe(1); expect(Object.keys(host.context._state.value.parts).length).toBe(1);
// Setup listener before calling start // Setup listener before calling start
const newPromptPromise = waitForPromptEvent(host); const newPromptPromise = waitForPromptEvent(host);
@ -173,15 +179,15 @@ describe("GameHost", () => {
const newRunPromise = host.start(); const newRunPromise = host.start();
// State should be back to initial // State should be back to initial
expect(host.state.value.currentPlayer).toBe("X"); expect(host.context._state.value.currentPlayer).toBe('X');
expect(host.state.value.winner).toBeNull(); expect(host.context._state.value.winner).toBeNull();
expect(host.state.value.turn).toBe(0); expect(host.context._state.value.turn).toBe(0);
expect(Object.keys(host.state.value.parts).length).toBe(0); expect(Object.keys(host.context._state.value.parts).length).toBe(0);
// New game should be running and prompting // New game should be running and prompting
const newPrompt = await newPromptPromise; const newPrompt = await newPromptPromise;
expect(newPrompt.schema.name).toBe("play"); expect(newPrompt.schema.name).toBe('play');
newPrompt.cancel("test end"); newPrompt.cancel('test end');
try { try {
await newRunPromise; await newRunPromise;
@ -190,7 +196,7 @@ describe("GameHost", () => {
} }
}); });
it("should cancel active prompt during start", async () => { it('should cancel active prompt during start', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
@ -206,31 +212,31 @@ describe("GameHost", () => {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toContain("Cancelled"); expect(error.message).toContain('Cancelled');
} }
// State should be reset // State should be reset
expect(host.state.value.currentPlayer).toBe("X"); expect(host.context._state.value.currentPlayer).toBe('X');
expect(host.state.value.turn).toBe(0); expect(host.context._state.value.turn).toBe(0);
}); });
it("should throw error when disposed", () => { it('should throw error when disposed', () => {
const { host } = createTestHost(); const { host } = createTestHost();
host.dispose(); host.dispose();
expect(() => host.start()).toThrow("GameHost is disposed"); expect(() => host.start()).toThrow('GameHost is disposed');
}); });
}); });
describe("dispose", () => { describe('dispose', () => {
it("should change status to disposed", () => { it('should change status to disposed', () => {
const { host } = createTestHost(); const { host } = createTestHost();
host.dispose(); host.dispose();
expect(host.status.value).toBe("disposed"); expect(host.status.value).toBe('disposed');
}); });
it("should cancel active prompt on dispose", async () => { it('should cancel active prompt on dispose', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
@ -245,25 +251,25 @@ describe("GameHost", () => {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toContain("Cancelled"); expect(error.message).toContain('Cancelled');
} }
}); });
it("should be idempotent", () => { it('should be idempotent', () => {
const { host } = createTestHost(); const { host } = createTestHost();
host.dispose(); host.dispose();
host.dispose(); // Should not throw host.dispose(); // Should not throw
expect(host.status.value).toBe("disposed"); expect(host.status.value).toBe('disposed');
}); });
}); });
describe("events", () => { describe('events', () => {
it("should emit start event", async () => { it('should emit start event', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
let setupCount = 0; let setupCount = 0;
host.on("start", () => { host.on('start', () => {
setupCount++; setupCount++;
}); });
@ -275,11 +281,11 @@ describe("GameHost", () => {
expect(setupCount).toBe(1); expect(setupCount).toBe(1);
// State should be running // State should be running
expect(host.status.value).toBe("running"); expect(host.status.value).toBe('running');
// Cancel the background setup command // Cancel the background setup command
const prompt = await promptPromise; const prompt = await promptPromise;
prompt.cancel("test end"); prompt.cancel('test end');
try { try {
await runPromise; await runPromise;
@ -288,11 +294,11 @@ describe("GameHost", () => {
} }
}); });
it("should emit dispose event", () => { it('should emit dispose event', () => {
const { host } = createTestHost(); const { host } = createTestHost();
let disposeCount = 0; let disposeCount = 0;
host.on("dispose", () => { host.on('dispose', () => {
disposeCount++; disposeCount++;
}); });
@ -300,11 +306,11 @@ describe("GameHost", () => {
expect(disposeCount).toBe(1); expect(disposeCount).toBe(1);
}); });
it("should allow unsubscribing from events", () => { it('should allow unsubscribing from events', () => {
const { host } = createTestHost(); const { host } = createTestHost();
let setupCount = 0; let setupCount = 0;
const unsubscribe = host.on("start", () => { const unsubscribe = host.on('start', () => {
setupCount++; setupCount++;
}); });
@ -312,48 +318,43 @@ describe("GameHost", () => {
// No event should be emitted // No event should be emitted
// (we can't easily test this without triggering setup, but we verify unsubscribe works) // (we can't easily test this without triggering setup, but we verify unsubscribe works)
expect(typeof unsubscribe).toBe("function"); expect(typeof unsubscribe).toBe('function');
}); });
}); });
describe("reactive state", () => { describe('reactive state', () => {
it("should have state that reflects game progress", async () => { it('should have state that reflects game progress', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
// Initial state // Initial state
expect(host.state.value.currentPlayer).toBe("X"); expect(host.context._state.value.currentPlayer).toBe('X');
expect(host.state.value.turn).toBe(0); expect(host.context._state.value.turn).toBe(0);
// Make a move // Make a move
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
const runPromise = host.start(); const runPromise = host.start();
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
promptEvent.tryCommit({ promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
name: "play",
params: ["X", 1, 1],
options: {},
flags: {},
});
// Wait for next prompt and cancel // Wait for next prompt and cancel
const nextPromptPromise = waitForPromptEvent(host); const nextPromptPromise = waitForPromptEvent(host);
const nextPrompt = await nextPromptPromise; const nextPrompt = await nextPromptPromise;
nextPrompt.cancel("test end"); nextPrompt.cancel('test end');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test end"); expect(error.message).toBe('test end');
} }
expect(host.state.value.currentPlayer).toBe("O"); expect(host.context._state.value.currentPlayer).toBe('O');
expect(host.state.value.turn).toBe(1); expect(host.context._state.value.turn).toBe(1);
expect(Object.keys(host.state.value.parts).length).toBe(1); expect(Object.keys(host.context._state.value.parts).length).toBe(1);
}); });
it("should update activePromptSchema reactively", async () => { it('should update activePromptSchema reactively', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
// Initially null // Initially null
@ -367,11 +368,11 @@ describe("GameHost", () => {
// Now schema should be set // Now schema should be set
expect(host.activePromptSchema.value).not.toBeNull(); expect(host.activePromptSchema.value).not.toBeNull();
expect(host.activePromptSchema.value?.name).toBe("play"); expect(host.activePromptSchema.value?.name).toBe('play');
// Cancel and wait // Cancel and wait
// @ts-ignore - accessing private _context for testing const cancelEvent = host.activePromptSchema.value;
host._context._commands._cancel(); host.context._commands._cancel();
try { try {
await runPromise; await runPromise;
} catch { } catch {
@ -383,30 +384,29 @@ describe("GameHost", () => {
}); });
}); });
describe("full game", () => { describe('full game', () => {
it("should run a complete game of tic-tac-toe with X winning diagonally", async () => { it('should run a complete game of tic-tac-toe with X winning diagonally', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
// Initial state // Initial state
expect(host.state.value.currentPlayer).toBe("X"); expect(host.context._state.value.currentPlayer).toBe('X');
expect(host.state.value.winner).toBeNull(); expect(host.context._state.value.winner).toBeNull();
expect(host.state.value.turn).toBe(0); expect(host.context._state.value.turn).toBe(0);
expect(Object.keys(host.state.value.parts).length).toBe(0); expect(Object.keys(host.context._state.value.parts).length).toBe(0);
// X wins diagonally: (0,0), (1,1), (2,2) // X wins diagonally: (0,0), (1,1), (2,2)
// O plays: (0,1), (2,1) // O plays: (0,1), (2,1)
const moves = [ const moves = [
"play X 0 0", // turn 1: X 'play X 0 0', // turn 1: X
"play O 0 1", // turn 2: O 'play O 0 1', // turn 2: O
"play X 1 1", // turn 3: X 'play X 1 1', // turn 3: X
"play O 2 1", // turn 4: O 'play O 2 1', // turn 4: O
"play X 2 2", // turn 5: X wins! 'play X 2 2', // turn 5: X wins!
]; ];
// Track prompt events in a queue // Track prompt events in a queue
const promptEvents: PromptEvent[] = []; const promptEvents: PromptEvent[] = [];
// @ts-ignore - accessing private _context for testing host.context._commands.on('prompt', (e) => {
host._context._commands.on("prompt", (e) => {
promptEvents.push(e); promptEvents.push(e);
}); });
@ -416,83 +416,71 @@ describe("GameHost", () => {
for (let i = 0; i < moves.length; i++) { for (let i = 0; i < moves.length; i++) {
// Wait until the next prompt event arrives // Wait until the next prompt event arrives
while (i >= promptEvents.length) { while (i >= promptEvents.length) {
await new Promise((r) => setTimeout(r, 10)); await new Promise(r => setTimeout(r, 10));
} }
const promptEvent = promptEvents[i]; const promptEvent = promptEvents[i];
expect(promptEvent.schema.name).toBe("play"); expect(promptEvent.schema.name).toBe('play');
// Submit the move // Submit the move
const error = host.tryInput(moves[i]); const error = host.tryInput(moves[i]);
expect(error).toBeNull(); expect(error).toBeNull();
// Wait for the command to complete before submitting next move // Wait for the command to complete before submitting next move
await new Promise((resolve) => setImmediate(resolve)); await new Promise(resolve => setImmediate(resolve));
} }
// Wait for setup to complete (game ended with winner) // Wait for setup to complete (game ended with winner)
try { try {
const finalState = await setupPromise; const finalState = await setupPromise;
expect(finalState.winner).toBe("X"); expect(finalState.winner).toBe('X');
// Final state checks // Final state checks
expect(host.state.value.winner).toBe("X"); expect(host.context._state.value.winner).toBe('X');
expect(host.state.value.currentPlayer).toBe("X"); expect(host.context._state.value.currentPlayer).toBe('X');
expect(Object.keys(host.state.value.parts).length).toBe(5); expect(Object.keys(host.context._state.value.parts).length).toBe(5);
// Verify winning diagonal // Verify winning diagonal
const parts = Object.values(host.state.value.parts); const parts = Object.values(host.context._state.value.parts);
const xPieces = parts.filter((p: any) => p.player === "X"); const xPieces = parts.filter(p => p.player === 'X');
expect(xPieces).toHaveLength(3); expect(xPieces).toHaveLength(3);
expect( expect(xPieces.some(p => JSON.stringify(p.position) === JSON.stringify([0, 0]))).toBe(true);
xPieces.some( expect(xPieces.some(p => JSON.stringify(p.position) === JSON.stringify([1, 1]))).toBe(true);
(p: any) => JSON.stringify(p.position) === JSON.stringify([0, 0]), expect(xPieces.some(p => JSON.stringify(p.position) === JSON.stringify([2, 2]))).toBe(true);
),
).toBe(true);
expect(
xPieces.some(
(p: any) => JSON.stringify(p.position) === JSON.stringify([1, 1]),
),
).toBe(true);
expect(
xPieces.some(
(p: any) => JSON.stringify(p.position) === JSON.stringify([2, 2]),
),
).toBe(true);
} catch (e) { } catch (e) {
// If setup fails due to cancellation, check state directly // If setup fails due to cancellation, check state directly
const error = e as Error; const error = e as Error;
if (!error.message.includes("Cancelled")) { if (!error.message.includes('Cancelled')) {
throw e; throw e;
} }
} }
host.dispose(); host.dispose();
expect(host.status.value).toBe("disposed"); expect(host.status.value).toBe('disposed');
}); });
}); });
describe("currentPlayer in prompt", () => { describe('currentPlayer in prompt', () => {
it("should have currentPlayer in PromptEvent", async () => { it('should have currentPlayer in PromptEvent', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
const runPromise = host.start(); const runPromise = host.start();
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
expect(promptEvent.currentPlayer).toBe("X"); expect(promptEvent.currentPlayer).toBe('X');
expect(host.activePromptPlayer.value).toBe("X"); expect(host.activePromptPlayer.value).toBe('X');
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
}); });
it("should update activePromptPlayer reactively", async () => { it('should update activePromptPlayer reactively', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
// Initially null // Initially null
@ -502,30 +490,25 @@ describe("GameHost", () => {
let promptPromise = waitForPromptEvent(host); let promptPromise = waitForPromptEvent(host);
let runPromise = host.start(); let runPromise = host.start();
let promptEvent = await promptPromise; let promptEvent = await promptPromise;
expect(promptEvent.currentPlayer).toBe("X"); expect(promptEvent.currentPlayer).toBe('X');
expect(host.activePromptPlayer.value).toBe("X"); expect(host.activePromptPlayer.value).toBe('X');
// Make a move // Make a move
promptEvent.tryCommit({ promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
name: "play",
params: ["X", 1, 1],
options: {},
flags: {},
});
// Second prompt - O's turn // Second prompt - O's turn
promptPromise = waitForPromptEvent(host); promptPromise = waitForPromptEvent(host);
promptEvent = await promptPromise; promptEvent = await promptPromise;
expect(promptEvent.currentPlayer).toBe("O"); expect(promptEvent.currentPlayer).toBe('O');
expect(host.activePromptPlayer.value).toBe("O"); expect(host.activePromptPlayer.value).toBe('O');
// Cancel // Cancel
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
// After prompt ends, player should be null // After prompt ends, player should be null
@ -533,35 +516,35 @@ describe("GameHost", () => {
}); });
}); });
describe("tryAnswerPrompt", () => { describe('tryAnswerPrompt', () => {
it("should answer prompt with valid arguments", async () => { it('should answer prompt with valid arguments', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
const runPromise = host.start(); const runPromise = host.start();
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
expect(promptEvent.schema.name).toBe("play"); expect(promptEvent.schema.name).toBe('play');
// Use tryAnswerPrompt with the prompt def // Use tryAnswerPrompt with the prompt def
const { prompts } = await import("@/samples/tic-tac-toe"); const { prompts } = await import('@/samples/tic-tac-toe');
const error = host.tryAnswerPrompt(prompts.play, "X", 1, 1); const error = host.tryAnswerPrompt(prompts.play, 'X', 1, 1);
expect(error).toBeNull(); expect(error).toBeNull();
// Wait for next prompt and cancel // Wait for next prompt and cancel
const nextPromptPromise = waitForPromptEvent(host); const nextPromptPromise = waitForPromptEvent(host);
const nextPrompt = await nextPromptPromise; const nextPrompt = await nextPromptPromise;
nextPrompt.cancel("test cleanup"); nextPrompt.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
}); });
it("should reject invalid arguments", async () => { it('should reject invalid arguments', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
const promptPromise = waitForPromptEvent(host); const promptPromise = waitForPromptEvent(host);
@ -570,26 +553,26 @@ describe("GameHost", () => {
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
// Use tryAnswerPrompt with invalid position // Use tryAnswerPrompt with invalid position
const { prompts } = await import("@/samples/tic-tac-toe"); const { prompts } = await import('@/samples/tic-tac-toe');
const error = host.tryAnswerPrompt(prompts.play, "X", 5, 5); const error = host.tryAnswerPrompt(prompts.play, 'X', 5, 5);
expect(error).not.toBeNull(); expect(error).not.toBeNull();
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch (e) { } catch (e) {
const error = e as Error; const error = e as Error;
expect(error.message).toBe("test cleanup"); expect(error.message).toBe('test cleanup');
} }
}); });
}); });
describe("addInterruption and clearInterruptions", () => { describe('addInterruption and clearInterruptions', () => {
it("should add interruption promise to state", async () => { it('should add interruption promise to state', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
let resolveInterruption: () => void; let resolveInterruption: () => void;
const interruptionPromise = new Promise<void>((resolve) => { const interruptionPromise = new Promise<void>(resolve => {
resolveInterruption = resolve; resolveInterruption = resolve;
}); });
@ -606,7 +589,7 @@ describe("GameHost", () => {
resolveInterruption!(); resolveInterruption!();
// Cancel and cleanup // Cancel and cleanup
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;
} catch { } catch {
@ -614,15 +597,15 @@ describe("GameHost", () => {
} }
}); });
it("should clear all pending interruptions", async () => { it('should clear all pending interruptions', async () => {
const { host } = createTestHost(); const { host } = createTestHost();
let resolveInterruption1: () => void; let resolveInterruption1: () => void;
let resolveInterruption2: () => void; let resolveInterruption2: () => void;
const interruptionPromise1 = new Promise<void>((resolve) => { const interruptionPromise1 = new Promise<void>(resolve => {
resolveInterruption1 = resolve; resolveInterruption1 = resolve;
}); });
const interruptionPromise2 = new Promise<void>((resolve) => { const interruptionPromise2 = new Promise<void>(resolve => {
resolveInterruption2 = resolve; resolveInterruption2 = resolve;
}); });
@ -638,7 +621,7 @@ describe("GameHost", () => {
const runPromise = host.start(); const runPromise = host.start();
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
promptEvent.cancel("test cleanup"); promptEvent.cancel('test cleanup');
try { try {
await runPromise; await runPromise;

134
tests/core/game.test.ts
View File

@ -1,24 +1,14 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { import { createGameContext, createGameCommandRegistry, createPromptDef, IGameContext, PromptDef } from '@/core/game';
createGameContext, import type { PromptEvent, Command } from '@/utils/command';
createGameCommandRegistry,
createPromptDef,
IGameContext,
PromptDef,
} from "@/core/game";
import type {
PromptEvent,
Command,
CommandRunnerContext,
} from "@/utils/command";
type MyState = { type MyState = {
score: number; score: number;
round: number; round: number;
}; };
describe("createGameContext", () => { describe('createGameContext', () => {
it("should create a game context with state", () => { it('should create a game context with state', () => {
const registry = createGameCommandRegistry(); const registry = createGameCommandRegistry();
const ctx = createGameContext(registry); const ctx = createGameContext(registry);
@ -26,7 +16,7 @@ describe("createGameContext", () => {
expect(ctx._state.value).toBeDefined(); expect(ctx._state.value).toBeDefined();
}); });
it("should wire commands to the context", () => { it('should wire commands to the context', () => {
const registry = createGameCommandRegistry(); const registry = createGameCommandRegistry();
const ctx = createGameContext(registry); const ctx = createGameContext(registry);
@ -34,7 +24,7 @@ describe("createGameContext", () => {
expect(ctx._commands.registry).toBe(registry); expect(ctx._commands.registry).toBe(registry);
}); });
it("should accept initial state as an object", () => { it('should accept initial state as an object', () => {
const registry = createGameCommandRegistry<MyState>(); const registry = createGameCommandRegistry<MyState>();
const ctx = createGameContext<MyState>(registry, { const ctx = createGameContext<MyState>(registry, {
score: 0, score: 0,
@ -45,7 +35,7 @@ describe("createGameContext", () => {
expect(ctx._state.value.round).toBe(1); expect(ctx._state.value.round).toBe(1);
}); });
it("should accept initial state as a factory function", () => { it('should accept initial state as a factory function', () => {
const registry = createGameCommandRegistry<MyState>(); const registry = createGameCommandRegistry<MyState>();
const ctx = createGameContext<MyState>(registry, () => ({ const ctx = createGameContext<MyState>(registry, () => ({
score: 10, score: 10,
@ -56,32 +46,24 @@ describe("createGameContext", () => {
expect(ctx._state.value.round).toBe(3); expect(ctx._state.value.round).toBe(3);
}); });
it("should forward prompt events via listener", async () => { it('should forward prompt events via listener', async () => {
const registry = createGameCommandRegistry(); const registry = createGameCommandRegistry();
const ctx = createGameContext(registry); const ctx = createGameContext(registry);
registry.register("test <value>", async function (_ctx, value) { registry.register('test <value>', async function (_ctx, value) {
return _ctx.prompt( return this.prompt({schema: 'prompt <answer>'}, () => 'ok');
createPromptDef("prompt <answer>"),
(answer) => answer,
);
}); });
const promptPromise = new Promise<PromptEvent>((resolve) => { const promptPromise = new Promise<PromptEvent>(resolve => {
ctx._commands.on("prompt", resolve); ctx._commands.on('prompt', resolve);
}); });
const runPromise = ctx.run("test hello"); const runPromise = ctx.run('test hello');
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe("prompt"); expect(promptEvent.schema.name).toBe('prompt');
const error = promptEvent.tryCommit({ const error = promptEvent.tryCommit({ name: 'prompt', params: ['yes'], options: {}, flags: {} });
name: "prompt",
params: ["yes"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
@ -89,41 +71,41 @@ describe("createGameContext", () => {
}); });
}); });
describe("createGameCommand", () => { describe('createGameCommand', () => {
it("should run a command with access to game context", async () => { it('should run a command with access to game context', async () => {
const registry = createGameCommandRegistry<{ marker: string }>(); const registry = createGameCommandRegistry<{ marker: string }>();
registry.register("set-marker <id>", async function (ctx, id) { registry.register('set-marker <id>', async function (ctx, id) {
ctx.produce((state) => { ctx.produce(state => {
state.marker = id; state.marker = id;
}); });
return id; return id;
}); });
const ctx = createGameContext(registry, { marker: "" }); const ctx = createGameContext(registry, { marker: '' });
const result = await ctx.run("set-marker board"); const result = await ctx.run('set-marker board');
if (!result.success) { if (!result.success) {
console.error("Error:", result.error); console.error('Error:', result.error);
} }
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("board"); expect(result.result).toBe('board');
} }
expect(ctx._state.value.marker).toBe("board"); expect(ctx._state.value.marker).toBe('board');
}); });
it("should run a typed command with extended context", async () => { it('should run a typed command with extended context', async () => {
const registry = createGameCommandRegistry<MyState>(); const registry = createGameCommandRegistry<MyState>();
registry.register( registry.register(
"add-score <amount:number>", 'add-score <amount:number>',
async function (ctx, amount) { async function (ctx, amount) {
ctx.produce((state) => { ctx.produce(state => {
state.score += amount; state.score += amount;
}); });
return ctx.value.score; return ctx.value.score;
}, }
); );
const ctx = createGameContext<MyState>(registry, () => ({ const ctx = createGameContext<MyState>(registry, () => ({
@ -131,7 +113,7 @@ describe("createGameCommand", () => {
round: 1, round: 1,
})); }));
const result = await ctx.run("add-score 5"); const result = await ctx.run('add-score 5');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe(5); expect(result.result).toBe(5);
@ -139,71 +121,67 @@ describe("createGameCommand", () => {
expect(ctx._state.value.score).toBe(5); expect(ctx._state.value.score).toBe(5);
}); });
it("should return error for unknown command", async () => { it('should return error for unknown command', async () => {
const registry = createGameCommandRegistry(); const registry = createGameCommandRegistry();
const ctx = createGameContext(registry); const ctx = createGameContext(registry);
const result = await ctx.run("nonexistent"); const result = await ctx.run('nonexistent');
expect(result.success).toBe(false); expect(result.success).toBe(false);
if (!result.success) { if (!result.success) {
expect(result.error).toContain("nonexistent"); expect(result.error).toContain('nonexistent');
} }
}); });
}); });
describe("createPromptDef", () => { describe('createPromptDef', () => {
it("should create a PromptDef with string schema", () => { it('should create a PromptDef with string schema', () => {
const promptDef = createPromptDef<[string, number]>( const promptDef = createPromptDef<[string, number]>('play <player> <score:number>');
"play <player> <score:number>",
);
expect(promptDef).toBeDefined(); expect(promptDef).toBeDefined();
expect(promptDef.schema.name).toBe("play"); expect(promptDef.schema.name).toBe('play');
expect(promptDef.schema.params).toHaveLength(2); expect(promptDef.schema.params).toHaveLength(2);
expect(promptDef.schema.params[0].name).toBe("player"); expect(promptDef.schema.params[0].name).toBe('player');
expect(promptDef.schema.params[1].name).toBe("score"); expect(promptDef.schema.params[1].name).toBe('score');
}); });
it("should create a PromptDef with CommandSchema object", () => { it('should create a PromptDef with CommandSchema object', () => {
const schemaObj = { const schemaObj = {
name: "test", name: 'test',
params: [], params: [],
options: {}, options: {},
flags: {}, flags: {}
}; };
const promptDef = createPromptDef<[]>(schemaObj); const promptDef = createPromptDef<[]>(schemaObj);
expect(promptDef.schema).toEqual(schemaObj); expect(promptDef.schema).toEqual(schemaObj);
}); });
it("should be usable with game.prompt", async () => { it('should be usable with game.prompt', async () => {
const registry = createGameCommandRegistry<{ score: number }>(); const registry = createGameCommandRegistry<{ score: number }>();
registry.register("test-prompt", async function (ctx) { registry.register('test-prompt', async function(ctx) {
const promptDef = createPromptDef<[number]>("input <value:number>"); const promptDef = createPromptDef<[number]>('input <value:number>');
const result = await ctx.prompt(promptDef, (value) => { const result = await ctx.prompt(
if (value < 0) throw "Value must be positive"; promptDef,
(value) => {
if (value < 0) throw 'Value must be positive';
return value; return value;
}); }
);
return result; return result;
}); });
const ctx = createGameContext(registry, { score: 0 }); const ctx = createGameContext(registry, { score: 0 });
const promptPromise = new Promise<PromptEvent>((resolve) => { const promptPromise = new Promise<PromptEvent>(resolve => {
ctx._commands.on("prompt", resolve); ctx._commands.on('prompt', resolve);
}); });
const runPromise = ctx.run("test-prompt"); const runPromise = ctx.run('test-prompt');
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
expect(promptEvent.schema.name).toBe("input"); expect(promptEvent.schema.name).toBe('input');
const error = promptEvent.tryCommit({ const error = promptEvent.tryCommit({ name: 'input', params: [42], options: {}, flags: {} });
name: "input",
params: [42],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;

586
tests/samples/boop.test.ts
View File

@ -1,81 +1,66 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { registry, createInitialState, BoopState } from "@/samples/boop"; import { registry, createInitialState, BoopState } from '@/samples/boop';
import { createGameContext } from "@/core/game"; import { createGameContext } from '@/core/game';
import type { PromptEvent } from "@/utils/command"; import type { PromptEvent } from '@/utils/command';
function createTestContext() { function createTestContext() {
const ctx = createGameContext(registry, createInitialState()); const ctx = createGameContext(registry, createInitialState());
return { registry, ctx }; return { registry, ctx };
} }
function waitForPrompt( function waitForPrompt(ctx: ReturnType<typeof createTestContext>['ctx']): Promise<PromptEvent> {
ctx: ReturnType<typeof createTestContext>["ctx"], return new Promise(resolve => {
): Promise<PromptEvent> { ctx._commands.on('prompt', resolve);
return new Promise((resolve) => {
ctx._commands.on("prompt", resolve);
}); });
} }
describe("Boop Game", () => { describe('Boop Game', () => {
describe("Setup", () => { describe('Setup', () => {
it("should create initial state correctly", () => { it('should create initial state correctly', () => {
const state = createInitialState(); const state = createInitialState();
expect(state.currentPlayer).toBe("white"); expect(state.currentPlayer).toBe('white');
expect(state.winner).toBeNull(); expect(state.winner).toBeNull();
expect(state.regions.board).toBeDefined(); expect(state.regions.board).toBeDefined();
expect(state.regions.white).toBeDefined(); expect(state.regions.white).toBeDefined();
expect(state.regions.black).toBeDefined(); expect(state.regions.black).toBeDefined();
// 8 kittens per player // 8 kittens per player
const whiteKittens = Object.values(state.pieces).filter( const whiteKittens = Object.values(state.pieces).filter(p => p.player === 'white' && p.type === 'kitten');
(p) => p.player === "white" && p.type === "kitten", const blackKittens = Object.values(state.pieces).filter(p => p.player === 'black' && p.type === 'kitten');
);
const blackKittens = Object.values(state.pieces).filter(
(p) => p.player === "black" && p.type === "kitten",
);
expect(whiteKittens.length).toBe(8); expect(whiteKittens.length).toBe(8);
expect(blackKittens.length).toBe(8); expect(blackKittens.length).toBe(8);
// 8 cats per player (initially in box) // 8 cats per player (initially in box)
const whiteCats = Object.values(state.pieces).filter( const whiteCats = Object.values(state.pieces).filter(p => p.player === 'white' && p.type === 'cat');
(p) => p.player === "white" && p.type === "cat", const blackCats = Object.values(state.pieces).filter(p => p.player === 'black' && p.type === 'cat');
);
const blackCats = Object.values(state.pieces).filter(
(p) => p.player === "black" && p.type === "cat",
);
expect(whiteCats.length).toBe(8); expect(whiteCats.length).toBe(8);
expect(blackCats.length).toBe(8); expect(blackCats.length).toBe(8);
// All cats should be in box (regionId = '') // All cats should be in box (regionId = '')
whiteCats.forEach((cat) => expect(cat.regionId).toBe("")); whiteCats.forEach(cat => expect(cat.regionId).toBe(''));
blackCats.forEach((cat) => expect(cat.regionId).toBe("")); blackCats.forEach(cat => expect(cat.regionId).toBe(''));
// Kittens should be in player supplies // Kittens should be in player supplies
whiteKittens.forEach((k) => expect(k.regionId).toBe("white")); whiteKittens.forEach(k => expect(k.regionId).toBe('white'));
blackKittens.forEach((k) => expect(k.regionId).toBe("black")); blackKittens.forEach(k => expect(k.regionId).toBe('black'));
}); });
}); });
describe("Place and Boop Commands", () => { describe('Place and Boop Commands', () => {
it("should place a kitten via play command", async () => { it('should place a kitten via play command', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Use turn command instead of setup which runs indefinitely // Use turn command instead of setup which runs indefinitely
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const runPromise = ctx.run("turn white"); const runPromise = ctx.run('turn white');
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
expect(promptEvent.schema.name).toBe("play"); expect(promptEvent.schema.name).toBe('play');
// Place a kitten at position 2,2 // Place a kitten at position 2,2
const error = promptEvent.tryCommit({ const error = promptEvent.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
@ -87,41 +72,29 @@ describe("Boop Game", () => {
expect(boardPieces.length).toBeGreaterThan(0); expect(boardPieces.length).toBeGreaterThan(0);
// Should have one less kitten in supply // Should have one less kitten in supply
const whiteSupply = state.regions.white.childIds.filter( const whiteSupply = state.regions.white.childIds.filter(id => state.pieces[id].type === 'kitten');
(id) => state.pieces[id].type === "kitten",
);
expect(whiteSupply.length).toBe(7); expect(whiteSupply.length).toBe(7);
}); });
}); });
describe("Boop Mechanics", () => { describe('Boop Mechanics', () => {
it("should boop adjacent pieces away from placement", async () => { it('should boop adjacent pieces away from placement', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// White places at 2,2 // White places at 2,2
let promptPromise = waitForPrompt(ctx); let promptPromise = waitForPrompt(ctx);
let runPromise = ctx.run("turn white"); let runPromise = ctx.run('turn white');
let promptEvent = await promptPromise; let promptEvent = await promptPromise;
let error = promptEvent.tryCommit({ let error = promptEvent.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
let result = await runPromise; let result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
// Black places at 2,3, which will boop white's piece // Black places at 2,3, which will boop white's piece
promptPromise = waitForPrompt(ctx); promptPromise = waitForPrompt(ctx);
runPromise = ctx.run("turn black"); runPromise = ctx.run('turn black');
promptEvent = await promptPromise; promptEvent = await promptPromise;
error = promptEvent.tryCommit({ error = promptEvent.tryCommit({ name: 'play', params: ['black', 2, 3, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["black", 2, 3, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
result = await runPromise; result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
@ -132,186 +105,152 @@ describe("Boop Game", () => {
expect(boardPieceCount).toBeGreaterThanOrEqual(1); expect(boardPieceCount).toBeGreaterThanOrEqual(1);
}); });
it("should handle pieces being booped off the board", async () => { it('should handle pieces being booped off the board', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// White places at corner // White places at corner
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const runPromise = ctx.run("turn white"); const runPromise = ctx.run('turn white');
const promptEvent = await promptPromise; const promptEvent = await promptPromise;
const error = promptEvent.tryCommit({ const error = promptEvent.tryCommit({ name: 'play', params: ['white', 0, 0, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 0, 0, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
const state = ctx.value; const state = ctx.value;
// Verify placement // Verify placement
expect(state.regions.board.partMap["0,0"]).toBeDefined(); expect(state.regions.board.partMap['0,0']).toBeDefined();
}); });
}); });
describe("Full Game Flow", () => { describe('Full Game Flow', () => {
it("should play a turn and switch players", async () => { it('should play a turn and switch players', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// White's turn - place at 2,2 // White's turn - place at 2,2
let promptPromise = waitForPrompt(ctx); let promptPromise = waitForPrompt(ctx);
let runPromise = ctx.run("turn white"); let runPromise = ctx.run('turn white');
let prompt = await promptPromise; let prompt = await promptPromise;
const error1 = prompt.tryCommit({ const error1 = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "kitten"],
options: {},
flags: {},
});
expect(error1).toBeNull(); expect(error1).toBeNull();
let result = await runPromise; let result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
const stateAfterWhite = ctx.value; const stateAfterWhite = ctx.value;
// Should have placed a piece // Should have placed a piece
expect(stateAfterWhite.regions.board.partMap["2,2"]).toBeDefined(); expect(stateAfterWhite.regions.board.partMap['2,2']).toBeDefined();
}); });
}); });
describe("Kitten vs Cat Hierarchy", () => { describe('Kitten vs Cat Hierarchy', () => {
it("should not boop cats when placing a kitten", async () => { it('should not boop cats when placing a kitten', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// White places a kitten at 2,2 // White places a kitten at 2,2
let promptPromise = waitForPrompt(ctx); let promptPromise = waitForPrompt(ctx);
let runPromise = ctx.run("turn white"); let runPromise = ctx.run('turn white');
let prompt = await promptPromise; let prompt = await promptPromise;
let error = prompt.tryCommit({ let error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
let result = await runPromise; let result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
// Manually move white's kitten to box and replace with a cat (for testing) // Manually move white's kitten to box and replace with a cat (for testing)
ctx.produce((state) => { ctx.produce(state => {
const whiteKitten = state.pieces["white-kitten-1"]; const whiteKitten = state.pieces['white-kitten-1'];
if (whiteKitten && whiteKitten.regionId === "board") { if (whiteKitten && whiteKitten.regionId === 'board') {
(whiteKitten as { type: string }).type = "cat"; whiteKitten.type = 'cat';
} }
}); });
// Black places a kitten at 2,3 (adjacent to the cat) // Black places a kitten at 2,3 (adjacent to the cat)
promptPromise = waitForPrompt(ctx); promptPromise = waitForPrompt(ctx);
runPromise = ctx.run("turn black"); runPromise = ctx.run('turn black');
prompt = await promptPromise; prompt = await promptPromise;
error = prompt.tryCommit({ error = prompt.tryCommit({ name: 'play', params: ['black', 2, 3, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["black", 2, 3, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
result = await runPromise; result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
const state = ctx.value; const state = ctx.value;
// White's cat should still be at 2,2 (not booped) // White's cat should still be at 2,2 (not booped)
expect(state.regions.board.partMap["2,2"]).toBe("white-kitten-1"); expect(state.regions.board.partMap['2,2']).toBe('white-kitten-1');
// Black's kitten should be at 2,3 // Black's kitten should be at 2,3
expect(state.regions.board.partMap["2,3"]).toBe("black-kitten-1"); expect(state.regions.board.partMap['2,3']).toBe('black-kitten-1');
}); });
it("should boop both kittens and cats when placing a cat", async () => { it('should boop both kittens and cats when placing a cat', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually set up: white cat at 2,3, black cat at 3,2 // Manually set up: white cat at 2,3, black cat at 3,2
// First move cats to white and black supplies // First move cats to white and black supplies
ctx.produce((state) => { ctx.produce(state => {
const whiteCat = state.pieces["white-cat-1"]; const whiteCat = state.pieces['white-cat-1'];
const blackCat = state.pieces["black-cat-1"]; const blackCat = state.pieces['black-cat-1'];
if (whiteCat && whiteCat.regionId === "") { if (whiteCat && whiteCat.regionId === '') {
whiteCat.regionId = "white"; whiteCat.regionId = 'white';
state.regions.white.childIds.push(whiteCat.id); state.regions.white.childIds.push(whiteCat.id);
} }
if (blackCat && blackCat.regionId === "") { if (blackCat && blackCat.regionId === '') {
blackCat.regionId = "black"; blackCat.regionId = 'black';
state.regions.black.childIds.push(blackCat.id); state.regions.black.childIds.push(blackCat.id);
} }
}); });
// Now move them to the board // Now move them to the board
ctx.produce((state) => { ctx.produce(state => {
const whiteCat = state.pieces["white-cat-1"]; const whiteCat = state.pieces['white-cat-1'];
const blackCat = state.pieces["black-cat-1"]; const blackCat = state.pieces['black-cat-1'];
if (whiteCat && whiteCat.regionId === "white") { if (whiteCat && whiteCat.regionId === 'white') {
whiteCat.regionId = "board"; whiteCat.regionId = 'board';
whiteCat.position = [2, 3]; whiteCat.position = [2, 3];
state.regions.board.partMap["2,3"] = whiteCat.id; state.regions.board.partMap['2,3'] = whiteCat.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== whiteCat.id);
(id) => id !== whiteCat.id,
);
} }
if (blackCat && blackCat.regionId === "black") { if (blackCat && blackCat.regionId === 'black') {
blackCat.regionId = "board"; blackCat.regionId = 'board';
blackCat.position = [3, 2]; blackCat.position = [3, 2];
state.regions.board.partMap["3,2"] = blackCat.id; state.regions.board.partMap['3,2'] = blackCat.id;
state.regions.black.childIds = state.regions.black.childIds.filter( state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== blackCat.id);
(id) => id !== blackCat.id,
);
} }
}); });
// Give white another cat for placement // Give white another cat for placement
ctx.produce((state) => { ctx.produce(state => {
const whiteCat2 = state.pieces["white-cat-2"]; const whiteCat2 = state.pieces['white-cat-2'];
if (whiteCat2 && whiteCat2.regionId === "") { if (whiteCat2 && whiteCat2.regionId === '') {
whiteCat2.regionId = "white"; whiteCat2.regionId = 'white';
state.regions.white.childIds.push(whiteCat2.id); state.regions.white.childIds.push(whiteCat2.id);
} }
}); });
// White places a cat at 2,2 (should boop black's cat at 3,2 to 4,2) // White places a cat at 2,2 (should boop black's cat at 3,2 to 4,2)
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const runPromise = ctx.run("turn white"); const runPromise = ctx.run('turn white');
const prompt = await promptPromise; const prompt = await promptPromise;
const error = prompt.tryCommit({ const error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'cat'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "cat"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
const state = ctx.value; const state = ctx.value;
// Black's cat should have been booped to 4,2 // Black's cat should have been booped to 4,2
expect(state.regions.board.partMap["4,2"]).toBeDefined(); expect(state.regions.board.partMap['4,2']).toBeDefined();
const pieceAt42 = state.pieces[state.regions.board.partMap["4,2"]]; const pieceAt42 = state.pieces[state.regions.board.partMap['4,2']];
expect(pieceAt42?.player).toBe("black"); expect(pieceAt42?.player).toBe('black');
expect(pieceAt42?.type).toBe("cat"); expect(pieceAt42?.type).toBe('cat');
}); });
}); });
describe("Boop Obstructions", () => { describe('Boop Obstructions', () => {
it("should boop pieces to empty positions", async () => { it('should boop pieces to empty positions', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// White places at 2,2 // White places at 2,2
let promptPromise = waitForPrompt(ctx); let promptPromise = waitForPrompt(ctx);
let runPromise = ctx.run("turn white"); let runPromise = ctx.run('turn white');
let prompt = await promptPromise; let prompt = await promptPromise;
let error = prompt.tryCommit({ let error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
let result = await runPromise; let result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
@ -322,14 +261,9 @@ describe("Boop Game", () => {
// Black places at 3,3 // Black places at 3,3
promptPromise = waitForPrompt(ctx); promptPromise = waitForPrompt(ctx);
runPromise = ctx.run("turn black"); runPromise = ctx.run('turn black');
prompt = await promptPromise; prompt = await promptPromise;
error = prompt.tryCommit({ error = prompt.tryCommit({ name: 'play', params: ['black', 3, 3, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["black", 3, 3, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
result = await runPromise; result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
@ -342,334 +276,294 @@ describe("Boop Game", () => {
expect(boardPieces.length).toBe(2); expect(boardPieces.length).toBe(2);
// Find black's piece // Find black's piece
const blackPiece = boardPieces.find( const blackPiece = boardPieces.find(([pos, id]) => state.pieces[id]?.player === 'black');
([pos, id]) => state.pieces[id]?.player === "black",
);
expect(blackPiece).toBeDefined(); expect(blackPiece).toBeDefined();
}); });
it("should keep both pieces in place when boop is blocked", async () => { it('should keep both pieces in place when boop is blocked', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Setup: place white at 2,2 and 4,4, black at 3,3 // Setup: place white at 2,2 and 4,4, black at 3,3
await ctx._commands.run("place 2 2 white kitten"); await ctx._commands.run('place 2 2 white kitten');
await ctx._commands.run("place 3 3 black kitten"); await ctx._commands.run('place 3 3 black kitten');
await ctx._commands.run("place 4 4 white kitten"); await ctx._commands.run('place 4 4 white kitten');
const stateBefore = ctx.value; const stateBefore = ctx.value;
// Verify setup - 3 pieces on board // Verify setup - 3 pieces on board
const boardPiecesBefore = Object.keys(stateBefore.regions.board.partMap); const boardPiecesBefore = Object.keys(stateBefore.regions.board.partMap);
expect(boardPiecesBefore.length).toBe(3); expect(boardPiecesBefore.length).toBe(3);
expect(stateBefore.regions.board.partMap["2,2"]).toBeDefined(); expect(stateBefore.regions.board.partMap['2,2']).toBeDefined();
expect(stateBefore.regions.board.partMap["3,3"]).toBeDefined(); expect(stateBefore.regions.board.partMap['3,3']).toBeDefined();
expect(stateBefore.regions.board.partMap["4,4"]).toBeDefined(); expect(stateBefore.regions.board.partMap['4,4']).toBeDefined();
// Black places at 2,3 - should try to boop piece at 3,3 to 4,4 // Black places at 2,3 - should try to boop piece at 3,3 to 4,4
// but 4,4 is occupied, so both should stay // but 4,4 is occupied, so both should stay
await ctx._commands.run("place 2 3 black kitten"); await ctx._commands.run('place 2 3 black kitten');
const state = ctx.value; const state = ctx.value;
// Should now have 4 pieces on board // Should now have 4 pieces on board
const boardPiecesAfter = Object.keys(state.regions.board.partMap); const boardPiecesAfter = Object.keys(state.regions.board.partMap);
expect(boardPiecesAfter.length).toBe(4); expect(boardPiecesAfter.length).toBe(4);
// 3,3 should still have the same piece (not booped) // 3,3 should still have the same piece (not booped)
expect(state.regions.board.partMap["3,3"]).toBeDefined(); expect(state.regions.board.partMap['3,3']).toBeDefined();
// 4,4 should still be occupied // 4,4 should still be occupied
expect(state.regions.board.partMap["4,4"]).toBeDefined(); expect(state.regions.board.partMap['4,4']).toBeDefined();
// 2,3 should have black's new piece // 2,3 should have black's new piece
expect(state.regions.board.partMap["2,3"]).toBeDefined(); expect(state.regions.board.partMap['2,3']).toBeDefined();
}); });
}); });
describe("Graduation Mechanic", () => { describe('Graduation Mechanic', () => {
it("should graduate three kittens in a row to cats", async () => { it('should graduate three kittens in a row to cats', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually place three white kittens in a row // Manually place three white kittens in a row
ctx.produce((state) => { ctx.produce(state => {
const k1 = state.pieces["white-kitten-1"]; const k1 = state.pieces['white-kitten-1'];
const k2 = state.pieces["white-kitten-2"]; const k2 = state.pieces['white-kitten-2'];
const k3 = state.pieces["white-kitten-3"]; const k3 = state.pieces['white-kitten-3'];
if (k1) { if (k1) {
k1.regionId = "board"; k1.regionId = 'board';
k1.position = [0, 0]; k1.position = [0, 0];
state.regions.board.partMap["0,0"] = k1.id; state.regions.board.partMap['0,0'] = k1.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k1.id);
(id) => id !== k1.id,
);
} }
if (k2) { if (k2) {
k2.regionId = "board"; k2.regionId = 'board';
k2.position = [0, 1]; k2.position = [0, 1];
state.regions.board.partMap["0,1"] = k2.id; state.regions.board.partMap['0,1'] = k2.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k2.id);
(id) => id !== k2.id,
);
} }
if (k3) { if (k3) {
k3.regionId = "board"; k3.regionId = 'board';
k3.position = [0, 2]; k3.position = [0, 2];
state.regions.board.partMap["0,2"] = k3.id; state.regions.board.partMap['0,2'] = k3.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k3.id);
(id) => id !== k3.id,
);
} }
}); });
const stateBefore = ctx.value; const stateBefore = ctx.value;
// Verify three kittens on board // Verify three kittens on board
expect(stateBefore.regions.board.partMap["0,0"]).toBeDefined(); expect(stateBefore.regions.board.partMap['0,0']).toBeDefined();
expect(stateBefore.regions.board.partMap["0,1"]).toBeDefined(); expect(stateBefore.regions.board.partMap['0,1']).toBeDefined();
expect(stateBefore.regions.board.partMap["0,2"]).toBeDefined(); expect(stateBefore.regions.board.partMap['0,2']).toBeDefined();
// Count cats in white supply before graduation // Count cats in white supply before graduation
const catsInWhiteSupplyBefore = stateBefore.regions.white.childIds.filter( const catsInWhiteSupplyBefore = stateBefore.regions.white.childIds.filter(
(id) => stateBefore.pieces[id].type === "cat", id => stateBefore.pieces[id].type === 'cat'
); );
expect(catsInWhiteSupplyBefore.length).toBe(0); expect(catsInWhiteSupplyBefore.length).toBe(0);
// Run check-graduates command // Run check-graduates command
const result = await ctx._commands.run("check-graduates"); const result = await ctx._commands.run('check-graduates');
expect(result.success).toBe(true); expect(result.success).toBe(true);
const state = ctx.value; const state = ctx.value;
// The three positions on board should now be empty (kittens removed) // The three positions on board should now be empty (kittens removed)
expect(state.regions.board.partMap["0,0"]).toBeUndefined(); expect(state.regions.board.partMap['0,0']).toBeUndefined();
expect(state.regions.board.partMap["0,1"]).toBeUndefined(); expect(state.regions.board.partMap['0,1']).toBeUndefined();
expect(state.regions.board.partMap["0,2"]).toBeUndefined(); expect(state.regions.board.partMap['0,2']).toBeUndefined();
// White's supply should now have 3 cats (graduated) // White's supply should now have 3 cats (graduated)
const catsInWhiteSupply = state.regions.white.childIds.filter( const catsInWhiteSupply = state.regions.white.childIds.filter(
(id) => state.pieces[id].type === "cat", id => state.pieces[id].type === 'cat'
); );
expect(catsInWhiteSupply.length).toBe(3); expect(catsInWhiteSupply.length).toBe(3);
// White's supply should have 5 kittens left (8 - 3 graduated) // White's supply should have 5 kittens left (8 - 3 graduated)
const kittensInWhiteSupply = state.regions.white.childIds.filter( const kittensInWhiteSupply = state.regions.white.childIds.filter(
(id) => state.pieces[id].type === "kitten", id => state.pieces[id].type === 'kitten'
); );
expect(kittensInWhiteSupply.length).toBe(5); expect(kittensInWhiteSupply.length).toBe(5);
}); });
}); });
describe("Win Detection", () => { describe('Win Detection', () => {
it("should detect horizontal win with three cats", async () => { it('should detect horizontal win with three cats', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually set up a winning scenario for white // Manually set up a winning scenario for white
ctx.produce((state) => { ctx.produce(state => {
const k1 = state.pieces["white-kitten-1"]; const k1 = state.pieces['white-kitten-1'];
const k2 = state.pieces["white-kitten-2"]; const k2 = state.pieces['white-kitten-2'];
const k3 = state.pieces["white-kitten-3"]; const k3 = state.pieces['white-kitten-3'];
if (k1) { if (k1) {
(k1 as { type: string }).type = "cat"; k1.type = 'cat';
k1.regionId = "board"; k1.regionId = 'board';
k1.position = [0, 0]; k1.position = [0, 0];
state.regions.board.partMap["0,0"] = k1.id; state.regions.board.partMap['0,0'] = k1.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k1.id);
(id) => id !== k1.id,
);
} }
if (k2) { if (k2) {
(k2 as { type: string }).type = "cat"; k2.type = 'cat';
k2.regionId = "board"; k2.regionId = 'board';
k2.position = [0, 1]; k2.position = [0, 1];
state.regions.board.partMap["0,1"] = k2.id; state.regions.board.partMap['0,1'] = k2.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k2.id);
(id) => id !== k2.id,
);
} }
if (k3) { if (k3) {
(k3 as { type: string }).type = "cat"; k3.type = 'cat';
k3.regionId = "board"; k3.regionId = 'board';
k3.position = [0, 2]; k3.position = [0, 2];
state.regions.board.partMap["0,2"] = k3.id; state.regions.board.partMap['0,2'] = k3.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k3.id);
(id) => id !== k3.id,
);
} }
}); });
// Run check-win command // Run check-win command
const result = await ctx._commands.run("check-win"); const result = await ctx._commands.run('check-win');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("white"); expect(result.result).toBe('white');
} }
}); });
it("should detect vertical win with three cats", async () => { it('should detect vertical win with three cats', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually set up a vertical winning scenario for black // Manually set up a vertical winning scenario for black
ctx.produce((state) => { ctx.produce(state => {
const k1 = state.pieces["black-kitten-1"]; const k1 = state.pieces['black-kitten-1'];
const k2 = state.pieces["black-kitten-2"]; const k2 = state.pieces['black-kitten-2'];
const k3 = state.pieces["black-kitten-3"]; const k3 = state.pieces['black-kitten-3'];
if (k1) { if (k1) {
(k1 as { type: string }).type = "cat"; k1.type = 'cat';
k1.regionId = "board"; k1.regionId = 'board';
k1.position = [0, 0]; k1.position = [0, 0];
state.regions.board.partMap["0,0"] = k1.id; state.regions.board.partMap['0,0'] = k1.id;
state.regions.black.childIds = state.regions.black.childIds.filter( state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== k1.id);
(id) => id !== k1.id,
);
} }
if (k2) { if (k2) {
(k2 as { type: string }).type = "cat"; k2.type = 'cat';
k2.regionId = "board"; k2.regionId = 'board';
k2.position = [1, 0]; k2.position = [1, 0];
state.regions.board.partMap["1,0"] = k2.id; state.regions.board.partMap['1,0'] = k2.id;
state.regions.black.childIds = state.regions.black.childIds.filter( state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== k2.id);
(id) => id !== k2.id,
);
} }
if (k3) { if (k3) {
(k3 as { type: string }).type = "cat"; k3.type = 'cat';
k3.regionId = "board"; k3.regionId = 'board';
k3.position = [2, 0]; k3.position = [2, 0];
state.regions.board.partMap["2,0"] = k3.id; state.regions.board.partMap['2,0'] = k3.id;
state.regions.black.childIds = state.regions.black.childIds.filter( state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== k3.id);
(id) => id !== k3.id,
);
} }
}); });
// Run check-win command // Run check-win command
const result = await ctx._commands.run("check-win"); const result = await ctx._commands.run('check-win');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("black"); expect(result.result).toBe('black');
} }
}); });
it("should detect diagonal win with three cats", async () => { it('should detect diagonal win with three cats', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually set up a diagonal winning scenario for white // Manually set up a diagonal winning scenario for white
ctx.produce((state) => { ctx.produce(state => {
const k1 = state.pieces["white-kitten-1"]; const k1 = state.pieces['white-kitten-1'];
const k2 = state.pieces["white-kitten-2"]; const k2 = state.pieces['white-kitten-2'];
const k3 = state.pieces["white-kitten-3"]; const k3 = state.pieces['white-kitten-3'];
if (k1) { if (k1) {
(k1 as { type: string }).type = "cat"; k1.type = 'cat';
k1.regionId = "board"; k1.regionId = 'board';
k1.position = [0, 0]; k1.position = [0, 0];
state.regions.board.partMap["0,0"] = k1.id; state.regions.board.partMap['0,0'] = k1.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k1.id);
(id) => id !== k1.id,
);
} }
if (k2) { if (k2) {
(k2 as { type: string }).type = "cat"; k2.type = 'cat';
k2.regionId = "board"; k2.regionId = 'board';
k2.position = [1, 1]; k2.position = [1, 1];
state.regions.board.partMap["1,1"] = k2.id; state.regions.board.partMap['1,1'] = k2.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k2.id);
(id) => id !== k2.id,
);
} }
if (k3) { if (k3) {
(k3 as { type: string }).type = "cat"; k3.type = 'cat';
k3.regionId = "board"; k3.regionId = 'board';
k3.position = [2, 2]; k3.position = [2, 2];
state.regions.board.partMap["2,2"] = k3.id; state.regions.board.partMap['2,2'] = k3.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k3.id);
(id) => id !== k3.id,
);
} }
}); });
// Run check-win command // Run check-win command
const result = await ctx._commands.run("check-win"); const result = await ctx._commands.run('check-win');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("white"); expect(result.result).toBe('white');
} }
}); });
}); });
describe("Placing Cats", () => { describe('Placing Cats', () => {
it("should allow placing a cat from supply", async () => { it('should allow placing a cat from supply', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually give a cat to white's supply // Manually give a cat to white's supply
ctx.produce((state) => { ctx.produce(state => {
const cat = state.pieces["white-cat-1"]; const cat = state.pieces['white-cat-1'];
if (cat && cat.regionId === "") { if (cat && cat.regionId === '') {
cat.regionId = "white"; cat.regionId = 'white';
state.regions.white.childIds.push(cat.id); state.regions.white.childIds.push(cat.id);
} }
}); });
// White places a cat at 2,2 // White places a cat at 2,2
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const runPromise = ctx.run("turn white"); const runPromise = ctx.run('turn white');
const prompt = await promptPromise; const prompt = await promptPromise;
const error = prompt.tryCommit({ const error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'cat'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "cat"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
const state = ctx.value; const state = ctx.value;
// Cat should be on the board // Cat should be on the board
expect(state.regions.board.partMap["2,2"]).toBe("white-cat-1"); expect(state.regions.board.partMap['2,2']).toBe('white-cat-1');
// Cat should no longer be in supply // Cat should no longer be in supply
const whiteCatsInSupply = state.regions.white.childIds.filter( const whiteCatsInSupply = state.regions.white.childIds.filter(id => state.pieces[id].type === 'cat');
(id) => state.pieces[id].type === "cat",
);
expect(whiteCatsInSupply.length).toBe(0); expect(whiteCatsInSupply.length).toBe(0);
}); });
}); });
describe("Check Full Board", () => { describe('Check Full Board', () => {
it("should not trigger when player has fewer than 8 pieces on board", async () => { it('should not trigger when player has fewer than 8 pieces on board', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// White places a single kitten // White places a single kitten
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const runPromise = ctx.run("turn white"); const runPromise = ctx.run('turn white');
const prompt = await promptPromise; const prompt = await promptPromise;
const error = prompt.tryCommit({ const error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 2, 2, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
// check-full-board should return without prompting // check-full-board should return without prompting
const fullBoardResult = await ctx._commands.run("check-full-board white"); const fullBoardResult = await ctx._commands.run('check-full-board white');
expect(fullBoardResult.success).toBe(true); expect(fullBoardResult.success).toBe(true);
}); });
it("should force graduation when all 8 pieces are on board", async () => { it('should force graduation when all 8 pieces are on board', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Manually place all 8 white pieces on the board // Manually place all 8 white pieces on the board
ctx.produce((state) => { ctx.produce(state => {
for (let i = 1; i <= 8; i++) { for (let i = 1; i <= 8; i++) {
const piece = state.pieces[`white-kitten-${i}`]; const piece = state.pieces[`white-kitten-${i}`];
if (piece) { if (piece) {
const row = Math.floor((i - 1) / 4); const row = Math.floor((i - 1) / 4);
const col = (i - 1) % 4; const col = (i - 1) % 4;
piece.regionId = "board"; piece.regionId = 'board';
piece.position = [row, col]; piece.position = [row, col];
state.regions.board.partMap[`${row},${col}`] = piece.id; state.regions.board.partMap[`${row},${col}`] = piece.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== piece.id);
(id) => id !== piece.id,
);
} }
} }
}); });
@ -680,17 +574,12 @@ describe("Boop Game", () => {
// Run check-full-board - should prompt for piece to graduate // Run check-full-board - should prompt for piece to graduate
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const runPromise = ctx._commands.run("check-full-board white"); const runPromise = ctx._commands.run('check-full-board white');
const prompt = await promptPromise; const prompt = await promptPromise;
expect(prompt.schema.name).toBe("choose"); expect(prompt.schema.name).toBe('choose');
// Select a piece to graduate // Select a piece to graduate
const error = prompt.tryCommit({ const error = prompt.tryCommit({ name: 'choose', params: ['white', 0, 0], options: {}, flags: {} });
name: "choose",
params: ["white", 0, 0],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
@ -698,73 +587,65 @@ describe("Boop Game", () => {
const state = ctx.value; const state = ctx.value;
// Position 0,0 should be empty (piece moved to box) // Position 0,0 should be empty (piece moved to box)
expect(state.regions.board.partMap["0,0"]).toBeUndefined(); expect(state.regions.board.partMap['0,0']).toBeUndefined();
}); });
it("should not trigger when player has a winner", async () => { it('should not trigger when player has a winner', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Set up a winning state for white // Set up a winning state for white
ctx.produce((state) => { ctx.produce(state => {
state.winner = "white"; state.winner = 'white';
for (let i = 1; i <= 8; i++) { for (let i = 1; i <= 8; i++) {
const piece = state.pieces[`white-kitten-${i}`]; const piece = state.pieces[`white-kitten-${i}`];
if (piece) { if (piece) {
const row = Math.floor((i - 1) / 4); const row = Math.floor((i - 1) / 4);
const col = (i - 1) % 4; const col = (i - 1) % 4;
piece.regionId = "board"; piece.regionId = 'board';
piece.position = [row, col]; piece.position = [row, col];
state.regions.board.partMap[`${row},${col}`] = piece.id; state.regions.board.partMap[`${row},${col}`] = piece.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== piece.id);
(id) => id !== piece.id,
);
} }
} }
}); });
// check-full-board should return without prompting // check-full-board should return without prompting
const fullBoardResult = await ctx._commands.run("check-full-board white"); const fullBoardResult = await ctx._commands.run('check-full-board white');
expect(fullBoardResult.success).toBe(true); expect(fullBoardResult.success).toBe(true);
}); });
}); });
describe("Start Command", () => { describe('Start Command', () => {
it("should run a complete game until there is a winner", async () => { it('should run a complete game until there is a winner', async () => {
const { ctx } = createTestContext(); const { ctx } = createTestContext();
// Set up a quick win scenario // Set up a quick win scenario
ctx.produce((state) => { ctx.produce(state => {
// Place three white cats in a row // Place three white cats in a row
const c1 = state.pieces["white-cat-1"]; const c1 = state.pieces['white-cat-1'];
const c2 = state.pieces["white-cat-2"]; const c2 = state.pieces['white-cat-2'];
const c3 = state.pieces["white-cat-3"]; const c3 = state.pieces['white-cat-3'];
if (c1) { if (c1) {
(c1 as { type: string }).type = "cat"; c1.type = 'cat';
c1.regionId = "board"; c1.regionId = 'board';
c1.position = [0, 0]; c1.position = [0, 0];
state.regions.board.partMap["0,0"] = c1.id; state.regions.board.partMap['0,0'] = c1.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== c1.id);
(id) => id !== c1.id,
);
} }
if (c2) { if (c2) {
(c2 as { type: string }).type = "cat"; c2.type = 'cat';
c2.regionId = "board"; c2.regionId = 'board';
c2.position = [0, 1]; c2.position = [0, 1];
state.regions.board.partMap["0,1"] = c2.id; state.regions.board.partMap['0,1'] = c2.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== c2.id);
(id) => id !== c2.id,
);
} }
if (c3) { if (c3) {
(c3 as { type: string }).type = "cat"; c3.type = 'cat';
c3.regionId = "board"; c3.regionId = 'board';
c3.position = [0, 2]; c3.position = [0, 2];
state.regions.board.partMap["0,2"] = c3.id; state.regions.board.partMap['0,2'] = c3.id;
state.regions.white.childIds = state.regions.white.childIds.filter( state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== c3.id);
(id) => id !== c3.id,
);
} }
}); });
@ -772,16 +653,11 @@ describe("Boop Game", () => {
// Note: start() runs indefinitely until there's a winner // Note: start() runs indefinitely until there's a winner
// Since we already set up a win, it should complete after one turn // Since we already set up a win, it should complete after one turn
const promptPromise = waitForPrompt(ctx); const promptPromise = waitForPrompt(ctx);
const startPromise = ctx.run("turn white"); const startPromise = ctx.run('turn white');
const prompt = await promptPromise; const prompt = await promptPromise;
// Complete the turn // Complete the turn
const error = prompt.tryCommit({ const error = prompt.tryCommit({ name: 'play', params: ['white', 3, 3, 'kitten'], options: {}, flags: {} });
name: "play",
params: ["white", 3, 3, "kitten"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await startPromise; const result = await startPromise;

196
tests/samples/regicide.test.ts
View File

@ -1,7 +1,6 @@
import { describe, it, expect } from "vitest"; import {createGameContext} from '@/core/game';
import { createGameContext } from "@/core/game"; import {registry} from '@/samples/regicide/commands';
import { registry } from "@/samples/regicide/commands"; import {createInitialState} from '@/samples/regicide/state';
import { createInitialState } from "@/samples/regicide/state";
import { import {
buildEnemyDeck, buildEnemyDeck,
buildTavernDeck, buildTavernDeck,
@ -9,55 +8,50 @@ import {
createCard, createCard,
createEnemy, createEnemy,
getCardValue, getCardValue,
isEnemyDefeated, isEnemyDefeated
} from "@/samples/regicide/utils"; } from '@/samples/regicide/utils';
import { Mulberry32RNG } from "@/utils/rng"; import {Mulberry32RNG} from '@/utils/rng';
import { import {CARD_VALUES, ENEMY_COUNT, FACE_CARDS, INITIAL_HAND_SIZE} from '@/samples/regicide/constants';
CARD_VALUES, import {PlayerType} from '@/samples/regicide/types';
ENEMY_COUNT,
FACE_CARDS,
INITIAL_HAND_SIZE,
} from "@/samples/regicide/constants";
import { PlayerType } from "@/samples/regicide/types";
describe("Regicide - Utils", () => { describe('Regicide - Utils', () => {
describe("getCardValue", () => { describe('getCardValue', () => {
it("should return correct value for number cards", () => { it('should return correct value for number cards', () => {
expect(getCardValue("A")).toBe(1); expect(getCardValue('A')).toBe(1);
expect(getCardValue("5")).toBe(5); expect(getCardValue('5')).toBe(5);
expect(getCardValue("10")).toBe(10); expect(getCardValue('10')).toBe(10);
}); });
it("should return correct value for face cards", () => { it('should return correct value for face cards', () => {
expect(getCardValue("J")).toBe(10); expect(getCardValue('J')).toBe(10);
expect(getCardValue("Q")).toBe(15); expect(getCardValue('Q')).toBe(15);
expect(getCardValue("K")).toBe(20); expect(getCardValue('K')).toBe(20);
}); });
}); });
describe("createCard", () => { describe('createCard', () => {
it("should create a card with correct properties", () => { it('should create a card with correct properties', () => {
const card = createCard("spades_A", "spades", "A"); const card = createCard('spades_A', 'spades', 'A');
expect(card.id).toBe("spades_A"); expect(card.id).toBe('spades_A');
expect(card.suit).toBe("spades"); expect(card.suit).toBe('spades');
expect(card.rank).toBe("A"); expect(card.rank).toBe('A');
expect(card.value).toBe(1); expect(card.value).toBe(1);
}); });
}); });
describe("createEnemy", () => { describe('createEnemy', () => {
it("should create an enemy with correct HP", () => { it('should create an enemy with correct HP', () => {
const enemy = createEnemy("enemy_0", "J", "spades"); const enemy = createEnemy('enemy_0', 'J', 'spades');
expect(enemy.rank).toBe("J"); expect(enemy.rank).toBe('J');
expect(enemy.value).toBe(10); expect(enemy.value).toBe(10);
expect(enemy.hp).toBe(20); expect(enemy.hp).toBe(20);
expect(enemy.maxHp).toBe(20); expect(enemy.maxHp).toBe(20);
}); });
it("should create enemy with different values for different ranks", () => { it('should create enemy with different values for different ranks', () => {
const jEnemy = createEnemy("enemy_0", "J", "spades"); const jEnemy = createEnemy('enemy_0', 'J', 'spades');
const qEnemy = createEnemy("enemy_1", "Q", "hearts"); const qEnemy = createEnemy('enemy_1', 'Q', 'hearts');
const kEnemy = createEnemy("enemy_2", "K", "diamonds"); const kEnemy = createEnemy('enemy_2', 'K', 'diamonds');
expect(jEnemy.value).toBe(10); expect(jEnemy.value).toBe(10);
expect(qEnemy.value).toBe(15); expect(qEnemy.value).toBe(15);
@ -69,30 +63,16 @@ describe("Regicide - Utils", () => {
}); });
}); });
describe("createAllCards", () => { describe('createAllCards', () => {
it("should create 52 cards", () => { it('should create 52 cards', () => {
const cards = createAllCards(); const cards = createAllCards();
expect(Object.keys(cards).length).toBe(52); expect(Object.keys(cards).length).toBe(52);
}); });
it("should have all suits and ranks", () => { it('should have all suits and ranks', () => {
const cards = createAllCards(); const cards = createAllCards();
const suits = ["spades", "hearts", "diamonds", "clubs"]; const suits = ['spades', 'hearts', 'diamonds', 'clubs'];
const ranks = [ const ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
"A",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
"J",
"Q",
"K",
];
for (const suit of suits) { for (const suit of suits) {
for (const rank of ranks) { for (const rank of ranks) {
@ -105,39 +85,39 @@ describe("Regicide - Utils", () => {
}); });
}); });
describe("buildEnemyDeck", () => { describe('buildEnemyDeck', () => {
it("should create 12 enemies (J/Q/K)", () => { it('should create 12 enemies (J/Q/K)', () => {
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const deck = buildEnemyDeck(rng); const deck = buildEnemyDeck(rng);
expect(deck.length).toBe(12); expect(deck.length).toBe(12);
}); });
it("should have J at top, Q in middle, K at bottom", () => { it('should have J at top, Q in middle, K at bottom', () => {
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const deck = buildEnemyDeck(rng); const deck = buildEnemyDeck(rng);
for (let i = 0; i < 4; i++) { for (let i = 0; i < 4; i++) {
expect(deck[i].rank).toBe("J"); expect(deck[i].rank).toBe('J');
} }
for (let i = 4; i < 8; i++) { for (let i = 4; i < 8; i++) {
expect(deck[i].rank).toBe("Q"); expect(deck[i].rank).toBe('Q');
} }
for (let i = 8; i < 12; i++) { for (let i = 8; i < 12; i++) {
expect(deck[i].rank).toBe("K"); expect(deck[i].rank).toBe('K');
} }
}); });
}); });
describe("buildTavernDeck", () => { describe('buildTavernDeck', () => {
it("should create 40 cards (A-10)", () => { it('should create 40 cards (A-10)', () => {
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const deck = buildTavernDeck(rng); const deck = buildTavernDeck(rng);
expect(deck.length).toBe(40); expect(deck.length).toBe(40);
}); });
it("should not contain face cards", () => { it('should not contain face cards', () => {
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const deck = buildTavernDeck(rng); const deck = buildTavernDeck(rng);
@ -147,9 +127,9 @@ describe("Regicide - Utils", () => {
}); });
}); });
describe("isEnemyDefeated", () => { describe('isEnemyDefeated', () => {
it("should return true when enemy HP <= 0", () => { it('should return true when enemy HP <= 0', () => {
const enemy = createEnemy("enemy_0", "J", "spades"); const enemy = createEnemy('enemy_0', 'J', 'spades');
expect(isEnemyDefeated(enemy)).toBe(false); expect(isEnemyDefeated(enemy)).toBe(false);
enemy.hp = 0; enemy.hp = 0;
@ -159,13 +139,13 @@ describe("Regicide - Utils", () => {
expect(isEnemyDefeated(enemy)).toBe(true); expect(isEnemyDefeated(enemy)).toBe(true);
}); });
it("should return false for null enemy", () => { it('should return false for null enemy', () => {
expect(isEnemyDefeated(null)).toBe(false); expect(isEnemyDefeated(null)).toBe(false);
}); });
}); });
}); });
describe("Regicide - Commands", () => { describe('Regicide - Commands', () => {
function createTestContext() { function createTestContext() {
const initialState = createInitialState(); const initialState = createInitialState();
return createGameContext(registry, initialState); return createGameContext(registry, initialState);
@ -177,12 +157,12 @@ describe("Regicide - Commands", () => {
const enemyDeck = buildEnemyDeck(rng); const enemyDeck = buildEnemyDeck(rng);
const tavernDeck = buildTavernDeck(rng); const tavernDeck = buildTavernDeck(rng);
game.produce((state) => { game.produce(state => {
state.cards = cards; state.cards = cards;
state.playerCount = 2; state.playerCount = 2;
state.currentPlayerIndex = 0; state.currentPlayerIndex = 0;
state.enemyDeck = [...enemyDeck]; state.enemyDeck = [...enemyDeck];
state.currentEnemy = { ...enemyDeck[0] }; state.currentEnemy = {...enemyDeck[0]};
for (const card of tavernDeck) { for (const card of tavernDeck) {
state.regions.tavernDeck.childIds.push(card.id); state.regions.tavernDeck.childIds.push(card.id);
@ -191,8 +171,8 @@ describe("Regicide - Commands", () => {
for (let i = 0; i < 6; i++) { for (let i = 0; i < 6; i++) {
const card1 = tavernDeck[i]; const card1 = tavernDeck[i];
const card2 = tavernDeck[i + 6]; const card2 = tavernDeck[i + 6];
card1.regionId = "hand_player1"; card1.regionId = 'hand_player1';
card2.regionId = "hand_player2"; card2.regionId = 'hand_player2';
state.playerHands.player1.push(card1.id); state.playerHands.player1.push(card1.id);
state.playerHands.player2.push(card2.id); state.playerHands.player2.push(card2.id);
state.regions.hand_player1.childIds.push(card1.id); state.regions.hand_player1.childIds.push(card1.id);
@ -201,8 +181,8 @@ describe("Regicide - Commands", () => {
}); });
} }
describe("play command", () => { describe('play command', () => {
it("should deal damage to current enemy", async () => { it('should deal damage to current enemy', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
@ -215,17 +195,17 @@ describe("Regicide - Commands", () => {
expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value); expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value);
}); });
it("should double damage for clubs suit", async () => { it('should double damage for clubs suit', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
game.produce((state) => { game.produce(state => {
state.cards["clubs_5"] = createCard("clubs_5", "clubs", "5"); state.cards['clubs_5'] = createCard('clubs_5', 'clubs', '5');
state.playerHands.player1.push("clubs_5"); state.playerHands.player1.push('clubs_5');
state.regions.hand_player1.childIds.push("clubs_5"); state.regions.hand_player1.childIds.push('clubs_5');
}); });
const clubsCardId = "clubs_5"; const clubsCardId = 'clubs_5';
const enemyHpBefore = game.value.currentEnemy!.hp; const enemyHpBefore = game.value.currentEnemy!.hp;
const card = game.value.cards[clubsCardId]; const card = game.value.cards[clubsCardId];
@ -235,79 +215,79 @@ describe("Regicide - Commands", () => {
}); });
}); });
describe("pass command", () => { describe('pass command', () => {
it("should allow player to pass", async () => { it('should allow player to pass', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
const result = await game.run("pass player1"); const result = await game.run('pass player1');
expect(result.success).toBe(true); expect(result.success).toBe(true);
}); });
}); });
describe("check-enemy command", () => { describe('check-enemy command', () => {
it("should detect defeated enemy and reveal next", async () => { it('should detect defeated enemy and reveal next', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
const firstEnemy = game.value.currentEnemy!; const firstEnemy = game.value.currentEnemy!;
game.produce((state) => { game.produce(state => {
state.currentEnemy!.hp = 0; state.currentEnemy!.hp = 0;
}); });
await game.run("check-enemy"); await game.run('check-enemy');
expect(game.value.regions.discardPile.childIds).toContain(firstEnemy.id); expect(game.value.regions.discardPile.childIds).toContain(firstEnemy.id);
expect(game.value.currentEnemy).not.toBe(firstEnemy); expect(game.value.currentEnemy).not.toBe(firstEnemy);
}); });
it("should not defeat enemy if HP > 0", async () => { it('should not defeat enemy if HP > 0', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
const currentEnemyId = game.value.currentEnemy!.id; const currentEnemyId = game.value.currentEnemy!.id;
await game.run("check-enemy"); await game.run('check-enemy');
expect(game.value.currentEnemy!.id).toBe(currentEnemyId); expect(game.value.currentEnemy!.id).toBe(currentEnemyId);
}); });
}); });
describe("next-turn command", () => { describe('next-turn command', () => {
it("should switch to next player", async () => { it('should switch to next player', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
expect(game.value.currentPlayerIndex).toBe(0); expect(game.value.currentPlayerIndex).toBe(0);
await game.run("next-turn"); await game.run('next-turn');
expect(game.value.currentPlayerIndex).toBe(1); expect(game.value.currentPlayerIndex).toBe(1);
}); });
it("should wrap around to first player", async () => { it('should wrap around to first player', async () => {
const game = createTestContext(); const game = createTestContext();
setupTestGame(game); setupTestGame(game);
game.produce((state) => { game.produce(state => {
state.currentPlayerIndex = 1; state.currentPlayerIndex = 1;
}); });
await game.run("next-turn"); await game.run('next-turn');
expect(game.value.currentPlayerIndex).toBe(0); expect(game.value.currentPlayerIndex).toBe(0);
}); });
}); });
}); });
describe("Regicide - Game Flow", () => { describe('Regicide - Game Flow', () => {
function createTestContext() { function createTestContext() {
const initialState = createInitialState(); const initialState = createInitialState();
return createGameContext(registry, initialState); return createGameContext(registry, initialState);
} }
it("should complete a full turn cycle", async () => { it('should complete a full turn cycle', async () => {
const game = createTestContext(); const game = createTestContext();
const cards = createAllCards(); const cards = createAllCards();
@ -315,12 +295,12 @@ describe("Regicide - Game Flow", () => {
const enemyDeck = buildEnemyDeck(rng); const enemyDeck = buildEnemyDeck(rng);
const tavernDeck = buildTavernDeck(rng); const tavernDeck = buildTavernDeck(rng);
game.produce((state) => { game.produce(state => {
state.cards = cards; state.cards = cards;
state.playerCount = 1; state.playerCount = 1;
state.currentPlayerIndex = 0; state.currentPlayerIndex = 0;
state.enemyDeck = [...enemyDeck.slice(1)]; state.enemyDeck = [...enemyDeck.slice(1)];
state.currentEnemy = { ...enemyDeck[0] }; state.currentEnemy = {...enemyDeck[0]};
for (const card of tavernDeck) { for (const card of tavernDeck) {
state.regions.tavernDeck.childIds.push(card.id); state.regions.tavernDeck.childIds.push(card.id);
@ -328,7 +308,7 @@ describe("Regicide - Game Flow", () => {
for (let i = 0; i < 6; i++) { for (let i = 0; i < 6; i++) {
const card = tavernDeck[i]; const card = tavernDeck[i];
card.regionId = "hand_player1"; card.regionId = 'hand_player1';
state.playerHands.player1.push(card.id); state.playerHands.player1.push(card.id);
state.regions.hand_player1.childIds.push(card.id); state.regions.hand_player1.childIds.push(card.id);
} }
@ -343,14 +323,14 @@ describe("Regicide - Game Flow", () => {
expect(game.value.currentEnemy!.hp).toBeLessThan(enemyHpBefore); expect(game.value.currentEnemy!.hp).toBeLessThan(enemyHpBefore);
}); });
it("should win game when all enemies defeated", async () => { it('should win game when all enemies defeated', async () => {
const game = createTestContext(); const game = createTestContext();
const cards = createAllCards(); const cards = createAllCards();
const rng = new Mulberry32RNG(12345); const rng = new Mulberry32RNG(12345);
const tavernDeck = buildTavernDeck(rng); const tavernDeck = buildTavernDeck(rng);
game.produce((state) => { game.produce(state => {
state.cards = cards; state.cards = cards;
state.playerCount = 1; state.playerCount = 1;
state.currentPlayerIndex = 0; state.currentPlayerIndex = 0;
@ -362,12 +342,12 @@ describe("Regicide - Game Flow", () => {
} }
}); });
game.produce((state) => { game.produce(state => {
state.phase = "victory"; state.phase = 'victory';
state.winner = true; state.winner = true;
}); });
expect(game.value.phase).toBe("victory"); expect(game.value.phase).toBe('victory');
expect(game.value.winner).toBe(true); expect(game.value.winner).toBe(true);
}); });
}); });

2
tests/samples/slay-the-spire-like/deck/factory.test.ts
View File

@ -14,7 +14,7 @@ import type {
GridInventory, GridInventory,
InventoryItem, InventoryItem,
} from "@/samples/slay-the-spire-like/system/grid-inventory"; } from "@/samples/slay-the-spire-like/system/grid-inventory";
import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types"; import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/encounter/types";
import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision"; import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
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 type { import type {

375
tests/samples/slay-the-spire-like/grid-inventory.test.ts
View File

@ -1,6 +1,6 @@
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 { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision"; import { IDENTITY_TRANSFORM } from '@/samples/slay-the-spire-like/system/utils/shape-collision';
import { import {
createGridInventory, createGridInventory,
placeItem, placeItem,
@ -14,16 +14,12 @@ import {
validatePlacement, validatePlacement,
type GridInventory, type GridInventory,
type InventoryItem, type InventoryItem,
} from "@/samples/slay-the-spire-like/system/grid-inventory"; } from '@/samples/slay-the-spire-like/system/grid-inventory';
/** /**
* Helper: create a test inventory item. * Helper: create a test inventory item.
*/ */
function createTestItem( function createTestItem(id: string, shapeStr: string, transform = IDENTITY_TRANSFORM): InventoryItem {
id: string,
shapeStr: string,
transform = IDENTITY_TRANSFORM,
): InventoryItem<Record<string, never>> {
const shape = parseShapeString(shapeStr); const shape = parseShapeString(shapeStr);
return { return {
id, id,
@ -32,9 +28,9 @@ function createTestItem(
}; };
} }
describe("grid-inventory", () => { describe('grid-inventory', () => {
describe("createGridInventory", () => { describe('createGridInventory', () => {
it("should create an empty inventory with correct dimensions", () => { it('should create an empty inventory with correct dimensions', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
expect(inv.width).toBe(6); expect(inv.width).toBe(6);
expect(inv.height).toBe(4); expect(inv.height).toBe(4);
@ -43,117 +39,111 @@ describe("grid-inventory", () => {
}); });
}); });
describe("placeItem", () => { describe('placeItem', () => {
it("should place a single-cell item", () => { it('should place a single-cell item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "o"); const item = createTestItem('sword', 'o');
placeItem(inv, item); placeItem(inv, item);
expect(inv.items.size).toBe(1); expect(inv.items.size).toBe(1);
expect(inv.items.has("sword")).toBe(true); expect(inv.items.has('sword')).toBe(true);
expect(inv.occupiedCells.has("0,0")).toBe(true); expect(inv.occupiedCells.has('0,0')).toBe(true);
}); });
it("should place a multi-cell item", () => { it('should place a multi-cell item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("axe", "oee"); const item = createTestItem('axe', 'oee');
placeItem(inv, item); placeItem(inv, item);
expect(inv.items.size).toBe(1); expect(inv.items.size).toBe(1);
expect(inv.occupiedCells.size).toBe(3); expect(inv.occupiedCells.size).toBe(3);
expect(inv.occupiedCells.has("0,0")).toBe(true); expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(inv.occupiedCells.has("1,0")).toBe(true); expect(inv.occupiedCells.has('1,0')).toBe(true);
expect(inv.occupiedCells.has("2,0")).toBe(true); expect(inv.occupiedCells.has('2,0')).toBe(true);
}); });
it("should place multiple items", () => { it('should place multiple items', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const itemA = createTestItem("a", "o"); const itemA = createTestItem('a', 'o');
const itemB = createTestItem("b", "o", { const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 0 } });
...IDENTITY_TRANSFORM,
offset: { x: 3, y: 0 },
});
placeItem(inv, itemA); placeItem(inv, itemA);
placeItem(inv, itemB); placeItem(inv, itemB);
expect(inv.items.size).toBe(2); expect(inv.items.size).toBe(2);
expect(inv.occupiedCells.size).toBe(2); expect(inv.occupiedCells.size).toBe(2);
expect(inv.occupiedCells.has("0,0")).toBe(true); expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(inv.occupiedCells.has("3,0")).toBe(true); expect(inv.occupiedCells.has('3,0')).toBe(true);
}); });
}); });
describe("removeItem", () => { describe('removeItem', () => {
it("should remove an item and free its cells", () => { it('should remove an item and free its cells', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "oee"); const item = createTestItem('sword', 'oee');
placeItem(inv, item); placeItem(inv, item);
removeItem(inv, "sword"); removeItem(inv, 'sword');
expect(inv.items.size).toBe(0); expect(inv.items.size).toBe(0);
expect(inv.occupiedCells.size).toBe(0); expect(inv.occupiedCells.size).toBe(0);
}); });
it("should only free the removed item's cells", () => { it('should only free the removed item\'s cells', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const itemA = createTestItem("a", "o"); const itemA = createTestItem('a', 'o');
const itemB = createTestItem("b", "o", { const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 0 },
});
placeItem(inv, itemA); placeItem(inv, itemA);
placeItem(inv, itemB); placeItem(inv, itemB);
removeItem(inv, "a"); removeItem(inv, 'a');
expect(inv.items.size).toBe(1); expect(inv.items.size).toBe(1);
expect(inv.occupiedCells.size).toBe(1); expect(inv.occupiedCells.size).toBe(1);
expect(inv.occupiedCells.has("0,0")).toBe(false); expect(inv.occupiedCells.has('0,0')).toBe(false);
expect(inv.occupiedCells.has("2,0")).toBe(true); expect(inv.occupiedCells.has('2,0')).toBe(true);
}); });
it("should do nothing for non-existent item", () => { it('should do nothing for non-existent item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
removeItem(inv, "nonexistent"); removeItem(inv, 'nonexistent');
expect(inv.items.size).toBe(0); expect(inv.items.size).toBe(0);
}); });
}); });
describe("validatePlacement", () => { describe('validatePlacement', () => {
it("should return valid for empty board", () => { it('should return valid for empty board', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const shape = parseShapeString("o"); const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM); const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
expect(result).toEqual({ valid: true }); expect(result).toEqual({ valid: true });
}); });
it("should return invalid for out of bounds", () => { it('should return invalid for out of bounds', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const shape = parseShapeString("o"); const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, { const result = validatePlacement(inv, shape, {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 6, y: 0 }, offset: { x: 6, y: 0 },
}); });
expect(result).toEqual({ valid: false, reason: "超出边界" }); expect(result).toEqual({ valid: false, reason: '超出边界' });
}); });
it("should return invalid for collision with existing item", () => { it('should return invalid for collision with existing item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const existing = createTestItem("a", "oee"); const existing = createTestItem('a', 'oee');
placeItem(inv, existing); placeItem(inv, existing);
const shape = parseShapeString("o"); const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM); const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
expect(result).toEqual({ valid: false, reason: "与已有物品重叠" }); expect(result).toEqual({ valid: false, reason: '与已有物品重叠' });
}); });
it("should return valid when there is room nearby", () => { it('should return valid when there is room nearby', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const existing = createTestItem("a", "o"); const existing = createTestItem('a', 'o');
placeItem(inv, existing); placeItem(inv, existing);
const shape = parseShapeString("o"); const shape = parseShapeString('o');
const result = validatePlacement(inv, shape, { const result = validatePlacement(inv, shape, {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 }, offset: { x: 1, y: 0 },
@ -162,169 +152,160 @@ describe("grid-inventory", () => {
}); });
}); });
describe("moveItem", () => { describe('moveItem', () => {
it("should move item to a new position", () => { it('should move item to a new position', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "o"); const item = createTestItem('sword', 'o');
placeItem(inv, item); placeItem(inv, item);
const result = moveItem(inv, "sword", { const result = moveItem(inv, 'sword', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 5, y: 3 }, offset: { x: 5, y: 3 },
}); });
expect(result).toEqual({ success: true }); expect(result).toEqual({ success: true });
expect(inv.occupiedCells.has("0,0")).toBe(false); expect(inv.occupiedCells.has('0,0')).toBe(false);
expect(inv.occupiedCells.has("5,3")).toBe(true); expect(inv.occupiedCells.has('5,3')).toBe(true);
expect(item.transform.offset).toEqual({ x: 5, y: 3 }); expect(item.transform.offset).toEqual({ x: 5, y: 3 });
}); });
it("should reject move that goes out of bounds", () => { it('should reject move that goes out of bounds', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "o"); const item = createTestItem('sword', 'o');
placeItem(inv, item); placeItem(inv, item);
const result = moveItem(inv, "sword", { const result = moveItem(inv, 'sword', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 6, y: 0 }, offset: { x: 6, y: 0 },
}); });
expect(result).toEqual({ success: false, reason: "超出边界" }); expect(result).toEqual({ success: false, reason: '超出边界' });
expect(inv.occupiedCells.has("0,0")).toBe(true); expect(inv.occupiedCells.has('0,0')).toBe(true);
expect(item.transform.offset).toEqual({ x: 0, y: 0 }); expect(item.transform.offset).toEqual({ x: 0, y: 0 });
}); });
it("should reject move that collides with another item", () => { it('should reject move that collides with another item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const itemA = createTestItem("a", "o"); const itemA = createTestItem('a', 'o');
const itemB = createTestItem("b", "o", { const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 0 },
});
placeItem(inv, itemA); placeItem(inv, itemA);
placeItem(inv, itemB); placeItem(inv, itemB);
const result = moveItem(inv, "b", { const result = moveItem(inv, 'b', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 0, y: 0 }, offset: { x: 0, y: 0 },
}); });
expect(result).toEqual({ success: false, reason: "与已有物品重叠" }); expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
expect(inv.occupiedCells.has("2,0")).toBe(true); expect(inv.occupiedCells.has('2,0')).toBe(true);
}); });
it("should return error for non-existent item", () => { it('should return error for non-existent item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const result = moveItem(inv, "ghost", IDENTITY_TRANSFORM); const result = moveItem(inv, 'ghost', IDENTITY_TRANSFORM);
expect(result).toEqual({ success: false, reason: "物品不存在" }); expect(result).toEqual({ success: false, reason: '物品不存在' });
}); });
it("should move multi-cell item correctly", () => { it('should move multi-cell item correctly', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
// oes: cells at (0,0), (1,0), (1,1) // oes: cells at (0,0), (1,0), (1,1)
const item = createTestItem("axe", "oes"); const item = createTestItem('axe', 'oes');
placeItem(inv, item); placeItem(inv, item);
const newTransform = { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 1 } }; const newTransform = { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 1 } };
moveItem(inv, "axe", newTransform); moveItem(inv, 'axe', newTransform);
// Old cells should be freed // Old cells should be freed
expect(inv.occupiedCells.has("0,0")).toBe(false); expect(inv.occupiedCells.has('0,0')).toBe(false);
expect(inv.occupiedCells.has("1,0")).toBe(false); expect(inv.occupiedCells.has('1,0')).toBe(false);
expect(inv.occupiedCells.has("1,1")).toBe(false); expect(inv.occupiedCells.has('1,1')).toBe(false);
// New cells: (0,0)+offset(3,1)=(3,1), (1,0)+(3,1)=(4,1), (1,1)+(3,1)=(4,2) // New cells: (0,0)+offset(3,1)=(3,1), (1,0)+(3,1)=(4,1), (1,1)+(3,1)=(4,2)
expect(inv.occupiedCells.has("3,1")).toBe(true); expect(inv.occupiedCells.has('3,1')).toBe(true);
expect(inv.occupiedCells.has("4,1")).toBe(true); expect(inv.occupiedCells.has('4,1')).toBe(true);
expect(inv.occupiedCells.has("4,2")).toBe(true); expect(inv.occupiedCells.has('4,2')).toBe(true);
}); });
}); });
describe("rotateItem", () => { describe('rotateItem', () => {
it("should rotate item by 90 degrees", () => { it('should rotate item by 90 degrees', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
// Horizontal line: (0,0), (1,0) // Horizontal line: (0,0), (1,0)
const item = createTestItem("bar", "oe", { const item = createTestItem('bar', 'oe', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 }, // Place away from edge so rotation stays in bounds offset: { x: 0, y: 1 }, // Place away from edge so rotation stays in bounds
}); });
placeItem(inv, item); placeItem(inv, item);
const result = rotateItem(inv, "bar", 90); const result = rotateItem(inv, 'bar', 90);
expect(result).toEqual({ success: true }); expect(result).toEqual({ success: true });
expect(item.transform.rotation).toBe(90); expect(item.transform.rotation).toBe(90);
}); });
it("should reject rotation that goes out of bounds", () => { it('should reject rotation that goes out of bounds', () => {
const inv = createGridInventory(3, 3); const inv = createGridInventory(3, 3);
// Item at the edge: place a 2-wide item at x=1 // Item at the edge: place a 2-wide item at x=1
const item = createTestItem("bar", "oe", { const item = createTestItem('bar', 'oe', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 }, offset: { x: 1, y: 0 },
}); });
placeItem(inv, item); placeItem(inv, item);
// Rotating 90° would make it vertical starting at (1,0), going to (1,-1) -> out of bounds // Rotating 90° would make it vertical starting at (1,0), going to (1,-1) -> out of bounds
const result = rotateItem(inv, "bar", 90); const result = rotateItem(inv, 'bar', 90);
expect(result).toEqual({ success: false, reason: "超出边界" }); expect(result).toEqual({ success: false, reason: '超出边界' });
}); });
it("should reject rotation that collides", () => { it('should reject rotation that collides', () => {
const inv = createGridInventory(4, 4); const inv = createGridInventory(4, 4);
const itemA = createTestItem("a", "o"); const itemA = createTestItem('a', 'o');
const itemB = createTestItem("b", "oe", { const itemB = createTestItem('b', 'oe', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 0 },
});
placeItem(inv, itemA); placeItem(inv, itemA);
placeItem(inv, itemB); placeItem(inv, itemB);
// Rotating b 90° would place cells at (2,0) and (2,-1) -> (2,-1) is out of bounds // Rotating b 90° would place cells at (2,0) and (2,-1) -> (2,-1) is out of bounds
// Let's try a different scenario: rotate b 270° -> (2,0) and (2,1) which is fine // Let's try a different scenario: rotate b 270° -> (2,0) and (2,1) which is fine
// But rotating to collide with a at (0,0)... need item close to a // But rotating to collide with a at (0,0)... need item close to a
const itemC = createTestItem("c", "os", { const itemC = createTestItem('c', 'os', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } });
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 0 },
});
placeItem(inv, itemC); placeItem(inv, itemC);
// Rotating c 90° would give cells at (1,0) and (0,0) -> collision with a // Rotating c 90° would give cells at (1,0) and (0,0) -> collision with a
const result = rotateItem(inv, "c", 90); const result = rotateItem(inv, 'c', 90);
expect(result).toEqual({ success: false, reason: "与已有物品重叠" }); expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
}); });
it("should return error for non-existent item", () => { it('should return error for non-existent item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const result = rotateItem(inv, "ghost", 90); const result = rotateItem(inv, 'ghost', 90);
expect(result).toEqual({ success: false, reason: "物品不存在" }); expect(result).toEqual({ success: false, reason: '物品不存在' });
}); });
}); });
describe("flipItem", () => { describe('flipItem', () => {
it("should flip item horizontally", () => { it('should flip item horizontally', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("bar", "oe"); const item = createTestItem('bar', 'oe');
placeItem(inv, item); placeItem(inv, item);
const result = flipItem(inv, "bar", "x"); const result = flipItem(inv, 'bar', 'x');
expect(result).toEqual({ success: true }); expect(result).toEqual({ success: true });
expect(item.transform.flipX).toBe(true); expect(item.transform.flipX).toBe(true);
}); });
it("should flip item vertically", () => { it('should flip item vertically', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("bar", "os"); const item = createTestItem('bar', 'os');
placeItem(inv, item); placeItem(inv, item);
const result = flipItem(inv, "bar", "y"); const result = flipItem(inv, 'bar', 'y');
expect(result).toEqual({ success: true }); expect(result).toEqual({ success: true });
expect(item.transform.flipY).toBe(true); expect(item.transform.flipY).toBe(true);
}); });
it("should reject flip that causes collision", () => { it('should reject flip that causes collision', () => {
// oes local cells: (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0). // oes local cells: (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
// Place flipper at offset (0,2): world cells (0,2),(1,2),(1,3). // Place flipper at offset (0,2): world cells (0,2),(1,2),(1,3).
// flipY gives local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2) — same cells rearranged. // flipY gives local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2) — same cells rearranged.
@ -332,10 +313,7 @@ describe("grid-inventory", () => {
// Use oes at offset (0,0): cells (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0). // Use oes at offset (0,0): cells (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
// Place blocker at (0,1) — which is NOT occupied by oes initially. // Place blocker at (0,1) — which is NOT occupied by oes initially.
const inv = createGridInventory(4, 4); const inv = createGridInventory(4, 4);
const blocker = createTestItem("blocker", "o", { const blocker = createTestItem('blocker', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 1 } });
...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 },
});
// oes at (0,1): cells (0,1),(1,1),(1,2). This overlaps blocker at (0,1)! // oes at (0,1): cells (0,1),(1,1),(1,2). This overlaps blocker at (0,1)!
// Let me try: blocker at (1,0), flipper at offset (0,2). // Let me try: blocker at (1,0), flipper at offset (0,2).
// flipper oes at (0,2): (0,2),(1,2),(1,3). blocker at (1,0) — no overlap. // flipper oes at (0,2): (0,2),(1,2),(1,3). blocker at (1,0) — no overlap.
@ -348,33 +326,30 @@ describe("grid-inventory", () => {
// Place flipper at (0,0): cells (0,0),(1,0),(1,1). Place blocker at (0,1) — but (0,1) is not occupied. // Place flipper at (0,0): cells (0,0),(1,0),(1,1). Place blocker at (0,1) — but (0,1) is not occupied.
// flipY: (0,1),(1,1),(1,0). (0,1) hits blocker! // flipY: (0,1),(1,1),(1,0). (0,1) hits blocker!
const inv2 = createGridInventory(4, 4); const inv2 = createGridInventory(4, 4);
const blocker2 = createTestItem("blocker", "o", { const blocker2 = createTestItem('blocker', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 1 } });
...IDENTITY_TRANSFORM, const flipper2 = createTestItem('flipper', 'oes'); // at (0,0): (0,0),(1,0),(1,1)
offset: { x: 0, y: 1 },
});
const flipper2 = createTestItem("flipper", "oes"); // at (0,0): (0,0),(1,0),(1,1)
placeItem(inv2, blocker2); placeItem(inv2, blocker2);
placeItem(inv2, flipper2); placeItem(inv2, flipper2);
const result = flipItem(inv2, "flipper", "y"); const result = flipItem(inv2, 'flipper', 'y');
expect(result).toEqual({ success: false, reason: "与已有物品重叠" }); expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
}); });
it("should return error for non-existent item", () => { it('should return error for non-existent item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const result = flipItem(inv, "ghost", "x"); const result = flipItem(inv, 'ghost', 'x');
expect(result).toEqual({ success: false, reason: "物品不存在" }); expect(result).toEqual({ success: false, reason: '物品不存在' });
}); });
}); });
describe("getOccupiedCellSet", () => { describe('getOccupiedCellSet', () => {
it("should return a copy of occupied cells", () => { it('should return a copy of occupied cells', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("a", "oe"); const item = createTestItem('a', 'oe');
placeItem(inv, item); placeItem(inv, item);
const cells = getOccupiedCellSet(inv); const cells = getOccupiedCellSet(inv);
expect(cells).toEqual(new Set(["0,0", "1,0"])); expect(cells).toEqual(new Set(['0,0', '1,0']));
// Mutating the copy should not affect the original // Mutating the copy should not affect the original
cells.clear(); cells.clear();
@ -382,68 +357,50 @@ describe("grid-inventory", () => {
}); });
}); });
describe("getItemAtCell", () => { describe('getItemAtCell', () => {
it("should return item at occupied cell", () => { it('should return item at occupied cell', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "oee"); const item = createTestItem('sword', 'oee');
placeItem(inv, item); placeItem(inv, item);
const found = getItemAtCell(inv, 1, 0); const found = getItemAtCell(inv, 1, 0);
expect(found).toBeDefined(); expect(found).toBeDefined();
expect(found!.id).toBe("sword"); expect(found!.id).toBe('sword');
}); });
it("should return undefined for empty cell", () => { it('should return undefined for empty cell', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("sword", "o"); const item = createTestItem('sword', 'o');
placeItem(inv, item); placeItem(inv, item);
const found = getItemAtCell(inv, 5, 5); const found = getItemAtCell(inv, 5, 5);
expect(found).toBeUndefined(); expect(found).toBeUndefined();
}); });
it("should return correct item when multiple items exist", () => { it('should return correct item when multiple items exist', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const itemA = createTestItem("a", "o"); const itemA = createTestItem('a', 'o');
const itemB = createTestItem("b", "o", { const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 2 } });
...IDENTITY_TRANSFORM,
offset: { x: 3, y: 2 },
});
placeItem(inv, itemA); placeItem(inv, itemA);
placeItem(inv, itemB); placeItem(inv, itemB);
expect(getItemAtCell(inv, 0, 0)!.id).toBe("a"); expect(getItemAtCell(inv, 0, 0)!.id).toBe('a');
expect(getItemAtCell(inv, 3, 2)!.id).toBe("b"); expect(getItemAtCell(inv, 3, 2)!.id).toBe('b');
}); });
}); });
describe("getAdjacentItems", () => { describe('getAdjacentItems', () => {
it("should return orthogonally adjacent items", () => { it('should return orthogonally adjacent items', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const center = createTestItem("center", "o", { const center = createTestItem('center', 'o', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 2, y: 2 }, offset: { x: 2, y: 2 },
}); });
const top = createTestItem("top", "o", { const top = createTestItem('top', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 1 } });
...IDENTITY_TRANSFORM, const left = createTestItem('left', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 2 } });
offset: { x: 2, y: 1 }, const right = createTestItem('right', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 2 } });
}); const bottom = createTestItem('bottom', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 3 } });
const left = createTestItem("left", "o", { const diagonal = createTestItem('diagonal', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 1 } });
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 2 },
});
const right = createTestItem("right", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 3, y: 2 },
});
const bottom = createTestItem("bottom", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 2, y: 3 },
});
const diagonal = createTestItem("diagonal", "o", {
...IDENTITY_TRANSFORM,
offset: { x: 1, y: 1 },
});
placeItem(inv, center); placeItem(inv, center);
placeItem(inv, top); placeItem(inv, top);
@ -452,87 +409,77 @@ describe("grid-inventory", () => {
placeItem(inv, bottom); placeItem(inv, bottom);
placeItem(inv, diagonal); placeItem(inv, diagonal);
const adj = getAdjacentItems(inv, "center"); const adj = getAdjacentItems(inv, 'center');
expect(adj.size).toBe(4); expect(adj.size).toBe(4);
expect(adj.has("top")).toBe(true); expect(adj.has('top')).toBe(true);
expect(adj.has("left")).toBe(true); expect(adj.has('left')).toBe(true);
expect(adj.has("right")).toBe(true); expect(adj.has('right')).toBe(true);
expect(adj.has("bottom")).toBe(true); expect(adj.has('bottom')).toBe(true);
expect(adj.has("diagonal")).toBe(false); expect(adj.has('diagonal')).toBe(false);
}); });
it("should return empty for item with no neighbors", () => { it('should return empty for item with no neighbors', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const item = createTestItem("alone", "o"); const item = createTestItem('alone', 'o');
placeItem(inv, item); placeItem(inv, item);
const adj = getAdjacentItems(inv, "alone"); const adj = getAdjacentItems(inv, 'alone');
expect(adj.size).toBe(0); expect(adj.size).toBe(0);
}); });
it("should return empty for non-existent item", () => { it('should return empty for non-existent item', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
const adj = getAdjacentItems(inv, "ghost"); const adj = getAdjacentItems(inv, 'ghost');
expect(adj.size).toBe(0); expect(adj.size).toBe(0);
}); });
it("should handle multi-cell items with multiple adjacencies", () => { it('should handle multi-cell items with multiple adjacencies', () => {
const inv = createGridInventory(6, 4); const inv = createGridInventory(6, 4);
// Horizontal bar at (0,0)-(1,0) // Horizontal bar at (0,0)-(1,0)
const bar = createTestItem("bar", "oe"); const bar = createTestItem('bar', 'oe');
// Item above left cell // Item above left cell
const topA = createTestItem("topA", "o", { const topA = createTestItem('topA', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: -1 } });
...IDENTITY_TRANSFORM,
offset: { x: 0, y: -1 },
});
// Item above right cell // Item above right cell
const topB = createTestItem("topB", "o", { const topB = createTestItem('topB', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: -1 } });
...IDENTITY_TRANSFORM,
offset: { x: 1, y: -1 },
});
placeItem(inv, bar); placeItem(inv, bar);
placeItem(inv, topA); placeItem(inv, topA);
placeItem(inv, topB); placeItem(inv, topB);
const adj = getAdjacentItems(inv, "bar"); const adj = getAdjacentItems(inv, 'bar');
expect(adj.size).toBe(2); expect(adj.size).toBe(2);
expect(adj.has("topA")).toBe(true); expect(adj.has('topA')).toBe(true);
expect(adj.has("topB")).toBe(true); expect(adj.has('topB')).toBe(true);
}); });
}); });
describe("integration: fill a 4x6 backpack", () => { describe('integration: fill a 4x6 backpack', () => {
it("should place items fitting a slay-the-spire-like backpack", () => { it('should place items fitting a slay-the-spire-like backpack', () => {
const inv = createGridInventory(4, 6); const inv = createGridInventory(4, 6);
// Sword: 1x3 horizontal at (0,0) // Sword: 1x3 horizontal at (0,0)
const sword = createTestItem("sword", "oee"); const sword = createTestItem('sword', 'oee');
// Shield: 2x2 at (0,1) // Shield: 2x2 at (0,1)
const shield = createTestItem("shield", "oes", { const shield = createTestItem('shield', 'oes', {
...IDENTITY_TRANSFORM, ...IDENTITY_TRANSFORM,
offset: { x: 0, y: 1 }, offset: { x: 0, y: 1 },
}); });
expect(validatePlacement(inv, sword.shape, sword.transform)).toEqual({ expect(validatePlacement(inv, sword.shape, sword.transform)).toEqual({ valid: true });
valid: true,
});
placeItem(inv, sword); placeItem(inv, sword);
expect(validatePlacement(inv, shield.shape, shield.transform)).toEqual({ expect(validatePlacement(inv, shield.shape, shield.transform)).toEqual({ valid: true });
valid: true,
});
placeItem(inv, shield); placeItem(inv, shield);
expect(inv.items.size).toBe(2); expect(inv.items.size).toBe(2);
expect(inv.occupiedCells.size).toBe(6); // sword(3) + shield(3) expect(inv.occupiedCells.size).toBe(6); // sword(3) + shield(3)
// Adjacent items should detect each other // Adjacent items should detect each other
const adjSword = getAdjacentItems(inv, "sword"); const adjSword = getAdjacentItems(inv, 'sword');
expect(adjSword.has("shield")).toBe(true); expect(adjSword.has('shield')).toBe(true);
const adjShield = getAdjacentItems(inv, "shield"); const adjShield = getAdjacentItems(inv, 'shield');
expect(adjShield.has("sword")).toBe(true); expect(adjShield.has('sword')).toBe(true);
}); });
}); });
}); });

295
tests/utils/command-runner.test.ts
View File

@ -1,5 +1,5 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { parseCommandSchema } from "@/utils/command/schema-parse"; import { parseCommandSchema } from '@/utils/command/schema-parse';
import { import {
createCommandRegistry, createCommandRegistry,
registerCommand, registerCommand,
@ -10,120 +10,109 @@ import {
createCommandRunnerContext, createCommandRunnerContext,
type CommandRegistry, type CommandRegistry,
type CommandRunnerContextExport, type CommandRunnerContextExport,
} from "@/utils/command/command-registry"; } from '@/utils/command/command-registry';
import type { import type { CommandRunner, PromptEvent } from '@/utils/command/command-runner';
CommandRunner,
PromptEvent,
} from "@/utils/command/command-runner";
type TestContext = { type TestContext = {
counter: number; counter: number;
log: string[]; log: string[];
}; };
describe("CommandRegistry", () => { describe('CommandRegistry', () => {
it("should create an empty registry", () => { it('should create an empty registry', () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
expect(registry.size).toBe(0); expect(registry.size).toBe(0);
}); });
it("should register a command", () => { it('should register a command', () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext, number> = { const runner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("add <a> <b>"), schema: parseCommandSchema('add <a> <b>'),
run: async function (cmd) { run: async function (cmd) {
return Number(cmd.params[0]) + Number(cmd.params[1]); return Number(cmd.params[0]) + Number(cmd.params[1]);
}, },
}; };
registerCommand(registry, runner); registerCommand(registry, runner);
expect(registry.size).toBe(1); expect(registry.size).toBe(1);
expect(hasCommand(registry, "add")).toBe(true); expect(hasCommand(registry, 'add')).toBe(true);
}); });
it("should unregister a command", () => { it('should unregister a command', () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext> = { const runner: CommandRunner<TestContext> = {
schema: parseCommandSchema("remove"), schema: parseCommandSchema('remove'),
run: async () => {}, run: async () => {},
}; };
registerCommand(registry, runner); registerCommand(registry, runner);
expect(hasCommand(registry, "remove")).toBe(true); expect(hasCommand(registry, 'remove')).toBe(true);
unregisterCommand(registry, "remove"); unregisterCommand(registry, 'remove');
expect(hasCommand(registry, "remove")).toBe(false); expect(hasCommand(registry, 'remove')).toBe(false);
}); });
it("should get a command runner", () => { it('should get a command runner', () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext> = { const runner: CommandRunner<TestContext> = {
schema: parseCommandSchema("get"), schema: parseCommandSchema('get'),
run: async () => {}, run: async () => {},
}; };
registerCommand(registry, runner); registerCommand(registry, runner);
const retrieved = getCommand(registry, "get"); const retrieved = getCommand(registry, 'get');
expect(retrieved).toBe(runner); expect(retrieved).toBe(runner);
}); });
it("should return undefined for unknown command", () => { it('should return undefined for unknown command', () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const retrieved = getCommand(registry, "unknown"); const retrieved = getCommand(registry, 'unknown');
expect(retrieved).toBeUndefined(); expect(retrieved).toBeUndefined();
}); });
}); });
describe("runCommand", () => { describe('runCommand', () => {
it("should run a command successfully", async () => { it('should run a command successfully', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext, number> = { const runner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("add <a> <b>"), schema: parseCommandSchema('add <a> <b>'),
run: async function (cmd) { run: async function (cmd) {
return Number(cmd.params[0]) + Number(cmd.params[1]); return Number(cmd.params[0]) + Number(cmd.params[1]);
}, },
}; };
registerCommand(registry, runner); registerCommand(registry, runner);
const result = await runCommand( const result = await runCommand(registry, { counter: 0, log: [] }, 'add 1 2');
registry,
{ counter: 0, log: [] },
"add 1 2",
);
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe(3); expect(result.result).toBe(3);
} }
}); });
it("should fail for unknown command", async () => { it('should fail for unknown command', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const result = await runCommand( const result = await runCommand(registry, { counter: 0, log: [] }, 'unknown');
registry,
{ counter: 0, log: [] },
"unknown",
);
expect(result.success).toBe(false); expect(result.success).toBe(false);
if (!result.success) { if (!result.success) {
expect(result.error).toContain("Unknown command"); expect(result.error).toContain('Unknown command');
} }
}); });
it("should fail for invalid command params", async () => { it('should fail for invalid command params', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext> = { const runner: CommandRunner<TestContext> = {
schema: parseCommandSchema("add <a> <b>"), schema: parseCommandSchema('add <a> <b>'),
run: async () => {}, run: async () => {},
}; };
registerCommand(registry, runner); registerCommand(registry, runner);
const result = await runCommand(registry, { counter: 0, log: [] }, "add 1"); const result = await runCommand(registry, { counter: 0, log: [] }, 'add 1');
expect(result.success).toBe(false); expect(result.success).toBe(false);
if (!result.success) { if (!result.success) {
expect(result.error).toContain("参数不足"); expect(result.error).toContain('参数不足');
} }
}); });
it("should access context via this.context", async () => { it('should access context via this.context', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext, number> = { const runner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("increment"), schema: parseCommandSchema('increment'),
run: async function () { run: async function () {
this.context.counter++; this.context.counter++;
return this.context.counter; return this.context.counter;
@ -132,30 +121,30 @@ describe("runCommand", () => {
registerCommand(registry, runner); registerCommand(registry, runner);
const ctx = { counter: 0, log: [] }; const ctx = { counter: 0, log: [] };
await runCommand(registry, ctx, "increment"); await runCommand(registry, ctx, 'increment');
expect(ctx.counter).toBe(1); expect(ctx.counter).toBe(1);
}); });
it("should handle async errors", async () => { it('should handle async errors', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext> = { const runner: CommandRunner<TestContext> = {
schema: parseCommandSchema("fail"), schema: parseCommandSchema('fail'),
run: async () => { run: async () => {
throw new Error("Something went wrong"); throw new Error('Something went wrong');
}, },
}; };
registerCommand(registry, runner); registerCommand(registry, runner);
const result = await runCommand(registry, { counter: 0, log: [] }, "fail"); const result = await runCommand(registry, { counter: 0, log: [] }, 'fail');
expect(result.success).toBe(false); expect(result.success).toBe(false);
if (!result.success) { if (!result.success) {
expect(result.error).toBe("Something went wrong"); expect(result.error).toBe('Something went wrong');
} }
}); });
}); });
describe("CommandRunnerContext", () => { describe('CommandRunnerContext', () => {
it("should create a runner context", () => { it('should create a runner context', () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const ctx = { counter: 0, log: [] }; const ctx = { counter: 0, log: [] };
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
@ -163,10 +152,10 @@ describe("CommandRunnerContext", () => {
expect(runnerCtx.context).toBe(ctx); expect(runnerCtx.context).toBe(ctx);
}); });
it("should run commands via runner context", async () => { it('should run commands via runner context', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const runner: CommandRunner<TestContext, string> = { const runner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("greet <name>"), schema: parseCommandSchema('greet <name>'),
run: async function (cmd) { run: async function (cmd) {
this.context.log.push(`Hello, ${cmd.params[0]}!`); this.context.log.push(`Hello, ${cmd.params[0]}!`);
return `Hello, ${cmd.params[0]}!`; return `Hello, ${cmd.params[0]}!`;
@ -176,19 +165,19 @@ describe("CommandRunnerContext", () => {
const ctx = { counter: 0, log: [] }; const ctx = { counter: 0, log: [] };
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
const result = await runnerCtx.run("greet World"); const result = await runnerCtx.run('greet World');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("Hello, World!"); expect(result.result).toBe('Hello, World!');
} }
expect(ctx.log).toEqual(["Hello, World!"]); expect(ctx.log).toEqual(['Hello, World!']);
}); });
it("should allow commands to call other commands via this.run", async () => { it('should allow commands to call other commands via this.run', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const addRunner: CommandRunner<TestContext, number> = { const addRunner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("add <a> <b>"), schema: parseCommandSchema('add <a> <b>'),
run: async function (cmd) { run: async function (cmd) {
return Number(cmd.params[0]) + Number(cmd.params[1]); return Number(cmd.params[0]) + Number(cmd.params[1]);
}, },
@ -197,12 +186,12 @@ describe("CommandRunnerContext", () => {
registerCommand(registry, addRunner); registerCommand(registry, addRunner);
const multiplyRunner: CommandRunner<TestContext, number> = { const multiplyRunner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("multiply <a> <b>"), schema: parseCommandSchema('multiply <a> <b>'),
run: async function (cmd) { run: async function (cmd) {
const a = Number(cmd.params[0]); const a = Number(cmd.params[0]);
const b = Number(cmd.params[1]); const b = Number(cmd.params[1]);
const addResult = await this.run(`add ${a} ${a}`); const addResult = await this.run(`add ${a} ${a}`);
if (!addResult.success) throw new Error("add failed"); if (!addResult.success) throw new Error('add failed');
return (addResult.result as number) * b; return (addResult.result as number) * b;
}, },
}; };
@ -210,18 +199,18 @@ describe("CommandRunnerContext", () => {
registerCommand(registry, multiplyRunner); registerCommand(registry, multiplyRunner);
const ctx = { counter: 0, log: [] }; const ctx = { counter: 0, log: [] };
const result = await runCommand(registry, ctx, "multiply 3 4"); const result = await runCommand(registry, ctx, 'multiply 3 4');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe(24); expect(result.result).toBe(24);
} }
}); });
it("should allow commands to call other commands via this.runParsed", async () => { it('should allow commands to call other commands via this.runParsed', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const doubleRunner: CommandRunner<TestContext, number> = { const doubleRunner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("double <n>"), schema: parseCommandSchema('double <n>'),
run: async function (cmd) { run: async function (cmd) {
return Number(cmd.params[0]) * 2; return Number(cmd.params[0]) * 2;
}, },
@ -230,16 +219,11 @@ describe("CommandRunnerContext", () => {
registerCommand(registry, doubleRunner); registerCommand(registry, doubleRunner);
const quadrupleRunner: CommandRunner<TestContext, number> = { const quadrupleRunner: CommandRunner<TestContext, number> = {
schema: parseCommandSchema("quadruple <n>"), schema: parseCommandSchema('quadruple <n>'),
run: async function (cmd) { run: async function (cmd) {
const n = Number(cmd.params[0]); const n = Number(cmd.params[0]);
const doubleResult = await this.runParsed({ const doubleResult = await this.runParsed({ name: 'double', params: [String(n)], options: {}, flags: {} });
name: "double", if (!doubleResult.success) throw new Error('double failed');
params: [String(n)],
options: {},
flags: {},
});
if (!doubleResult.success) throw new Error("double failed");
return (doubleResult.result as number) * 2; return (doubleResult.result as number) * 2;
}, },
}; };
@ -247,7 +231,7 @@ describe("CommandRunnerContext", () => {
registerCommand(registry, quadrupleRunner); registerCommand(registry, quadrupleRunner);
const ctx = { counter: 0, log: [] }; const ctx = { counter: 0, log: [] };
const result = await runCommand(registry, ctx, "quadruple 5"); const result = await runCommand(registry, ctx, 'quadruple 5');
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe(20); expect(result.result).toBe(20);
@ -255,17 +239,14 @@ describe("CommandRunnerContext", () => {
}); });
}); });
describe("prompt", () => { describe('prompt', () => {
it("should dispatch prompt event with string schema", async () => { it('should dispatch prompt event with string schema', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = { const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("choose"), schema: parseCommandSchema('choose'),
run: async function () { run: async function () {
const result = await this.prompt( const result = await this.prompt('select <card>', (cmd) => cmd.params[0] as string);
parseCommandSchema("select <card>"),
(cmd) => cmd.params[0] as string,
);
return result; return result;
}, },
}; };
@ -276,30 +257,27 @@ describe("prompt", () => {
let promptEvent: PromptEvent | null = null; let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvent = e; promptEvent = e;
}); });
const runPromise = runnerCtx.run("choose"); const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
expect(promptEvent!.schema.name).toBe("select"); expect(promptEvent!.schema.name).toBe('select');
promptEvent!.cancel("test cleanup"); promptEvent!.cancel('test cleanup');
await runPromise; await runPromise;
}); });
it("should resolve prompt with valid input", async () => { it('should resolve prompt with valid input', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = { const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("choose"), schema: parseCommandSchema('choose'),
run: async function () { run: async function () {
const result = await this.prompt( const result = await this.prompt('select <card>', (card) => card as string);
parseCommandSchema("select <card>"),
(card) => card as string,
);
this.context.log.push(`selected ${result}`); this.context.log.push(`selected ${result}`);
return result; return result;
}, },
@ -311,39 +289,36 @@ describe("prompt", () => {
let promptEvent: PromptEvent | null = null; let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvent = e; promptEvent = e;
}); });
const runPromise = runnerCtx.run("choose"); const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
const parsed = { name: "select", params: ["Ace"], options: {}, flags: {} }; const parsed = { name: 'select', params: ['Ace'], options: {}, flags: {} };
const error = promptEvent!.tryCommit(parsed); const error = promptEvent!.tryCommit(parsed);
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("Ace"); expect(result.result).toBe('Ace');
} }
expect(ctx.log).toEqual(["selected Ace"]); expect(ctx.log).toEqual(['selected Ace']);
}); });
it("should reject prompt with invalid input", async () => { it('should reject prompt with invalid input', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = { const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("choose"), schema: parseCommandSchema('choose'),
run: async function () { run: async function () {
try { try {
await this.prompt( await this.prompt('select <card>', (card) => card as string);
parseCommandSchema("select <card>"), return 'unexpected success';
(card) => card as string,
);
return "unexpected success";
} catch (e) { } catch (e) {
return (e as Error).message; return (e as Error).message;
} }
@ -356,30 +331,30 @@ describe("prompt", () => {
let promptEvent: PromptEvent | null = null; let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvent = e; promptEvent = e;
}); });
const runPromise = runnerCtx.run("choose"); const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
promptEvent!.cancel("user cancelled"); promptEvent!.cancel('user cancelled');
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("user cancelled"); expect(result.result).toBe('user cancelled');
} }
}); });
it("should accept CommandSchema object in prompt", async () => { it('should accept CommandSchema object in prompt', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const schema = parseCommandSchema("pick <item>"); const schema = parseCommandSchema('pick <item>');
const pickRunner: CommandRunner<TestContext, string> = { const pickRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("pick"), schema: parseCommandSchema('pick'),
run: async function () { run: async function () {
const result = await this.prompt(schema, (item) => item as string); const result = await this.prompt(schema, (item) => item as string);
return result; return result;
@ -392,45 +367,34 @@ describe("prompt", () => {
let promptEvent: PromptEvent | null = null; let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvent = e; promptEvent = e;
}); });
const runPromise = runnerCtx.run("pick"); const runPromise = runnerCtx.run('pick');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
expect(promptEvent!.schema.name).toBe("pick"); expect(promptEvent!.schema.name).toBe('pick');
const error = promptEvent!.tryCommit({ const error = promptEvent!.tryCommit({ name: 'pick', params: ['sword'], options: {}, flags: {} });
name: "pick",
params: ["sword"],
options: {},
flags: {},
});
expect(error).toBeNull(); expect(error).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("sword"); expect(result.result).toBe('sword');
} }
}); });
it("should allow multiple sequential prompts", async () => { it('should allow multiple sequential prompts', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const multiPromptRunner: CommandRunner<TestContext, string[]> = { const multiPromptRunner: CommandRunner<TestContext, string[]> = {
schema: parseCommandSchema("multi"), schema: parseCommandSchema('multi'),
run: async function () { run: async function () {
const first = await this.prompt( const first = await this.prompt('first <a>', (a) => a as string);
parseCommandSchema("first <a>"), const second = await this.prompt('second <b>', (b) => b as string);
(a) => a as string,
);
const second = await this.prompt(
parseCommandSchema("second <b>"),
(b) => b as string,
);
return [first, second]; return [first, second];
}, },
}; };
@ -441,58 +405,48 @@ describe("prompt", () => {
const promptEvents: PromptEvent[] = []; const promptEvents: PromptEvent[] = [];
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvents.push(e); promptEvents.push(e);
}); });
const runPromise = runnerCtx.run("multi"); const runPromise = runnerCtx.run('multi');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvents.length).toBe(1); expect(promptEvents.length).toBe(1);
expect(promptEvents[0].schema.name).toBe("first"); expect(promptEvents[0].schema.name).toBe('first');
const error1 = promptEvents[0].tryCommit({ const error1 = promptEvents[0].tryCommit({ name: 'first', params: ['one'], options: {}, flags: {} });
name: "first",
params: ["one"],
options: {},
flags: {},
});
expect(error1).toBeNull(); expect(error1).toBeNull();
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvents.length).toBe(2); expect(promptEvents.length).toBe(2);
expect(promptEvents[1].schema.name).toBe("second"); expect(promptEvents[1].schema.name).toBe('second');
const error2 = promptEvents[1].tryCommit({ const error2 = promptEvents[1].tryCommit({ name: 'second', params: ['two'], options: {}, flags: {} });
name: "second",
params: ["two"],
options: {},
flags: {},
});
expect(error2).toBeNull(); expect(error2).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toEqual(["one", "two"]); expect(result.result).toEqual(['one', 'two']);
} }
}); });
it("should validate input with validator function", async () => { it('should validate input with validator function', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = { const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("choose"), schema: parseCommandSchema('choose'),
run: async function () { run: async function () {
const result = await this.prompt( const result = await this.prompt(
parseCommandSchema("select <card>"), 'select <card>',
(card) => { (card) => {
const cardStr = card as string; const cardStr = card as string;
if (!["Ace", "King", "Queen"].includes(cardStr)) { if (!['Ace', 'King', 'Queen'].includes(cardStr)) {
throw `Invalid card: ${cardStr}. Must be Ace, King, or Queen.`; throw `Invalid card: ${cardStr}. Must be Ace, King, or Queen.`;
} }
return cardStr; return cardStr;
}, }
); );
return result; return result;
}, },
@ -504,52 +458,39 @@ describe("prompt", () => {
let promptEvent: PromptEvent | null = null; let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvent = e; promptEvent = e;
}); });
const runPromise = runnerCtx.run("choose"); const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
// Try invalid input // Try invalid input
const invalidError = promptEvent!.tryCommit({ const invalidError = promptEvent!.tryCommit({ name: 'select', params: ['Jack'], options: {}, flags: {} });
name: "select", expect(invalidError).toContain('Invalid card: Jack');
params: ["Jack"],
options: {},
flags: {},
});
expect(invalidError).toContain("Invalid card: Jack");
// Try valid input // Try valid input
const validError = promptEvent!.tryCommit({ const validError = promptEvent!.tryCommit({ name: 'select', params: ['Ace'], options: {}, flags: {} });
name: "select",
params: ["Ace"],
options: {},
flags: {},
});
expect(validError).toBeNull(); expect(validError).toBeNull();
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("Ace"); expect(result.result).toBe('Ace');
} }
}); });
it("should allow cancel with custom reason", async () => { it('should allow cancel with custom reason', async () => {
const registry = createCommandRegistry<TestContext>(); const registry = createCommandRegistry<TestContext>();
const chooseRunner: CommandRunner<TestContext, string> = { const chooseRunner: CommandRunner<TestContext, string> = {
schema: parseCommandSchema("choose"), schema: parseCommandSchema('choose'),
run: async function () { run: async function () {
try { try {
await this.prompt( await this.prompt('select <card>', (cmd) => cmd.params[0] as string);
parseCommandSchema("select <card>"), return 'unexpected success';
(cmd) => cmd.params[0] as string,
);
return "unexpected success";
} catch (e) { } catch (e) {
return (e as Error).message; return (e as Error).message;
} }
@ -562,21 +503,21 @@ describe("prompt", () => {
let promptEvent: PromptEvent | null = null; let promptEvent: PromptEvent | null = null;
const runnerCtx = createCommandRunnerContext(registry, ctx); const runnerCtx = createCommandRunnerContext(registry, ctx);
runnerCtx.on("prompt", (e) => { runnerCtx.on('prompt', (e) => {
promptEvent = e; promptEvent = e;
}); });
const runPromise = runnerCtx.run("choose"); const runPromise = runnerCtx.run('choose');
await new Promise((r) => setTimeout(r, 0)); await new Promise((r) => setTimeout(r, 0));
expect(promptEvent).not.toBeNull(); expect(promptEvent).not.toBeNull();
promptEvent!.cancel("custom cancellation reason"); promptEvent!.cancel('custom cancellation reason');
const result = await runPromise; const result = await runPromise;
expect(result.success).toBe(true); expect(result.success).toBe(true);
if (result.success) { if (result.success) {
expect(result.result).toBe("custom cancellation reason"); expect(result.result).toBe('custom cancellation reason');
} }
}); });
}); });

155
tests/utils/middleware.test.ts
View File

@ -1,30 +1,27 @@
import { describe, it, expect } from "vitest"; import { describe, it, expect } from 'vitest';
import { import { createMiddlewareChain, type MiddlewareChain } from '@/utils/middleware';
createMiddlewareChain,
type MiddlewareChain,
} from "@/utils/middleware";
describe("createMiddlewareChain", () => { describe('createMiddlewareChain', () => {
describe("basic execution", () => { describe('basic execution', () => {
it("should return context when no middlewares and no fallback", async () => { it('should return context when no middlewares and no fallback', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
const result = await chain.execute({ value: 42 }); const result = await chain.execute({ value: 42 });
expect(result).toEqual({ value: 42 }); expect(result).toEqual({ value: 42 });
}); });
it("should call fallback when no middlewares", async () => { it('should call fallback when no middlewares', async () => {
const chain = createMiddlewareChain<{ value: number }, string>( const chain = createMiddlewareChain<{ value: number }, string>(
async (ctx) => `value is ${ctx.value}`, async ctx => `value is ${ctx.value}`
); );
const result = await chain.execute({ value: 42 }); const result = await chain.execute({ value: 42 });
expect(result).toBe("value is 42"); expect(result).toBe('value is 42');
}); });
it("should pass context to fallback", async () => { it('should pass context to fallback', async () => {
const chain = createMiddlewareChain<{ a: number; b: number }, number>( const chain = createMiddlewareChain<{ a: number; b: number }, number>(
async (ctx) => ctx.a + ctx.b, async ctx => ctx.a + ctx.b
); );
const result = await chain.execute({ a: 3, b: 7 }); const result = await chain.execute({ a: 3, b: 7 });
@ -32,8 +29,8 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("single middleware", () => { describe('single middleware', () => {
it("should execute a single middleware", async () => { it('should execute a single middleware', async () => {
const chain = createMiddlewareChain<{ count: number }>(); const chain = createMiddlewareChain<{ count: number }>();
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
ctx.count *= 2; ctx.count *= 2;
@ -45,9 +42,9 @@ describe("createMiddlewareChain", () => {
expect(result.count).toBe(10); expect(result.count).toBe(10);
}); });
it("should allow middleware to modify return value", async () => { it('should allow middleware to modify return value', async () => {
const chain = createMiddlewareChain<{ value: number }, number>( const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => ctx.value, async ctx => ctx.value
); );
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
const result = await next(); const result = await next();
@ -59,7 +56,7 @@ describe("createMiddlewareChain", () => {
expect(result).toBe(42); expect(result).toBe(42);
}); });
it("should allow middleware to short-circuit without calling next", async () => { it('should allow middleware to short-circuit without calling next', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, _next) => { chain.use(async (_ctx, _next) => {
return { value: 999 }; return { value: 999 };
@ -71,8 +68,8 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("multiple middlewares", () => { describe('multiple middlewares', () => {
it("should execute middlewares in order", async () => { it('should execute middlewares in order', async () => {
const order: number[] = []; const order: number[] = [];
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
@ -94,7 +91,7 @@ describe("createMiddlewareChain", () => {
expect(order).toEqual([1, 2, 3, 4]); expect(order).toEqual([1, 2, 3, 4]);
}); });
it("should accumulate modifications through the chain", async () => { it('should accumulate modifications through the chain', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
@ -115,9 +112,9 @@ describe("createMiddlewareChain", () => {
expect(result.value).toBe(5); expect(result.value).toBe(5);
}); });
it("should allow middleware to modify result on the way back", async () => { it('should allow middleware to modify result on the way back', async () => {
const chain = createMiddlewareChain<{ base: number }, number>( const chain = createMiddlewareChain<{ base: number }, number>(
async (ctx) => ctx.base, async ctx => ctx.base
); );
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
@ -134,7 +131,7 @@ describe("createMiddlewareChain", () => {
expect(result).toBe(20); expect(result).toBe(20);
}); });
it("should allow middleware to short-circuit in the middle", async () => { it('should allow middleware to short-circuit in the middle', async () => {
const executed: number[] = []; const executed: number[] = [];
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
@ -158,14 +155,13 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("nested next calls", () => { describe('nested next calls', () => {
it("should advance index on each next call, skipping remaining middlewares", async () => { it('should advance index on each next call, skipping remaining middlewares', async () => {
const chain = createMiddlewareChain<{ counter: number }>(); const chain = createMiddlewareChain<{ counter: number }>();
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
await next(); await next();
await next(); await next();
return undefined as unknown as { counter: number };
}); });
const result = await chain.execute({ counter: 0 }); const result = await chain.execute({ counter: 0 });
@ -173,12 +169,12 @@ describe("createMiddlewareChain", () => {
expect(result).toBeUndefined(); expect(result).toBeUndefined();
}); });
it("should allow middleware to call next conditionally", async () => { it('should allow middleware to call next conditionally', async () => {
const chain = createMiddlewareChain<{ skip: boolean; value: number }>(); const chain = createMiddlewareChain<{ skip: boolean; value: number }>();
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
if (ctx.skip) { if (ctx.skip) {
return { skip: ctx.skip, value: -1 }; return { value: -1 };
} }
return next(); return next();
}); });
@ -194,33 +190,33 @@ describe("createMiddlewareChain", () => {
expect(resultB.value).toBe(10); expect(resultB.value).toBe(10);
}); });
it("should handle middleware that awaits next multiple times with a fallback", async () => { it('should handle middleware that awaits next multiple times with a fallback', async () => {
const log: string[] = []; const log: string[] = [];
const chain = createMiddlewareChain<{ value: number }, string[]>( const chain = createMiddlewareChain<{ value: number }, string[]>(
async (_ctx) => log, async _ctx => log
); );
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
log.push("before"); log.push('before');
await next(); await next();
log.push("after-first"); log.push('after-first');
await next(); await next();
log.push("after-second"); log.push('after-second');
return log; return log;
}); });
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
log.push("mw2"); log.push('mw2');
return next(); return next();
}); });
const result = await chain.execute({ value: 0 }); const result = await chain.execute({ value: 0 });
expect(result).toEqual(["before", "mw2", "after-first", "after-second"]); expect(result).toEqual(['before', 'mw2', 'after-first', 'after-second']);
}); });
it("should return fallback result on second next call when no more middlewares remain", async () => { it('should return fallback result on second next call when no more middlewares remain', async () => {
const chain = createMiddlewareChain<{ value: number }, number>( const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => ctx.value * 10, async ctx => ctx.value * 10
); );
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
@ -236,9 +232,9 @@ describe("createMiddlewareChain", () => {
expect(result).toBe(50); expect(result).toBe(50);
}); });
it("should return fallback result on second next call when no more middlewares remain", async () => { it('should return fallback result on second next call when no more middlewares remain', async () => {
const chain = createMiddlewareChain<{ value: number }, number>( const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => ctx.value * 10, async ctx => ctx.value * 10
); );
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
@ -255,17 +251,17 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("async behavior", () => { describe('async behavior', () => {
it("should handle async middlewares", async () => { it('should handle async middlewares', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
await new Promise((resolve) => setTimeout(resolve, 10)); await new Promise(resolve => setTimeout(resolve, 10));
ctx.value += 1; ctx.value += 1;
return next(); return next();
}); });
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
await new Promise((resolve) => setTimeout(resolve, 10)); await new Promise(resolve => setTimeout(resolve, 10));
ctx.value += 2; ctx.value += 2;
return next(); return next();
}); });
@ -275,12 +271,12 @@ describe("createMiddlewareChain", () => {
expect(result.value).toBe(3); expect(result.value).toBe(3);
}); });
it("should handle async fallback", async () => { it('should handle async fallback', async () => {
const chain = createMiddlewareChain<{ value: number }, number>( const chain = createMiddlewareChain<{ value: number }, number>(
async (ctx) => { async ctx => {
await new Promise((resolve) => setTimeout(resolve, 10)); await new Promise(resolve => setTimeout(resolve, 10));
return ctx.value * 10; return ctx.value * 10;
}, }
); );
const result = await chain.execute({ value: 5 }); const result = await chain.execute({ value: 5 });
@ -289,32 +285,28 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("error handling", () => { describe('error handling', () => {
it("should propagate errors from middleware", async () => { it('should propagate errors from middleware', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
chain.use(async () => { chain.use(async () => {
throw new Error("middleware error"); throw new Error('middleware error');
}); });
await expect(chain.execute({ value: 1 })).rejects.toThrow( await expect(chain.execute({ value: 1 })).rejects.toThrow('middleware error');
"middleware error",
);
}); });
it("should propagate errors from fallback", async () => { it('should propagate errors from fallback', async () => {
const chain = createMiddlewareChain<{ value: number }, number>( const chain = createMiddlewareChain<{ value: number }, number>(
async () => { async () => {
throw new Error("fallback error"); throw new Error('fallback error');
}, }
); );
await expect(chain.execute({ value: 1 })).rejects.toThrow( await expect(chain.execute({ value: 1 })).rejects.toThrow('fallback error');
"fallback error",
);
}); });
it("should allow middleware to catch errors from downstream", async () => { it('should allow middleware to catch errors from downstream', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
@ -325,7 +317,7 @@ describe("createMiddlewareChain", () => {
} }
}); });
chain.use(async () => { chain.use(async () => {
throw new Error("downstream error"); throw new Error('downstream error');
}); });
const result = await chain.execute({ value: 1 }); const result = await chain.execute({ value: 1 });
@ -334,20 +326,20 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("return type override", () => { describe('return type override', () => {
it("should support different TReturn type than TContext", async () => { it('should support different TReturn type than TContext', async () => {
const chain = createMiddlewareChain<{ name: string }, string>( const chain = createMiddlewareChain<{ name: string }, string>(
async (ctx) => `Hello, ${ctx.name}!`, async ctx => `Hello, ${ctx.name}!`
); );
const result = await chain.execute({ name: "World" }); const result = await chain.execute({ name: 'World' });
expect(result).toBe("Hello, World!"); expect(result).toBe('Hello, World!');
}); });
it("should allow middleware to transform return type", async () => { it('should allow middleware to transform return type', async () => {
const chain = createMiddlewareChain<{ items: number[] }, number>( const chain = createMiddlewareChain<{ items: number[] }, number>(
async (ctx) => ctx.items.reduce((a, b) => a + b, 0), async ctx => ctx.items.reduce((a, b) => a + b, 0)
); );
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
@ -361,8 +353,8 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("reusability", () => { describe('reusability', () => {
it("should reset index on each execute call", async () => { it('should reset index on each execute call', async () => {
const chain = createMiddlewareChain<{ count: number }>(); const chain = createMiddlewareChain<{ count: number }>();
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
@ -377,11 +369,11 @@ describe("createMiddlewareChain", () => {
expect(resultB.count).toBe(1); expect(resultB.count).toBe(1);
}); });
it("should share middlewares across execute calls", async () => { it('should share middlewares across execute calls', async () => {
const chain = createMiddlewareChain<{ log: string[] }>(); const chain = createMiddlewareChain<{ log: string[] }>();
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
ctx.log.push("always"); ctx.log.push('always');
return next(); return next();
}); });
@ -392,17 +384,17 @@ describe("createMiddlewareChain", () => {
}); });
}); });
describe("edge cases", () => { describe('edge cases', () => {
it("should handle empty context object", async () => { it('should handle empty context object', async () => {
const chain = createMiddlewareChain<Record<string, never>>(); const chain = createMiddlewareChain<Record<string, never>>();
const result = await chain.execute({}); const result = await chain.execute({});
expect(result).toEqual({}); expect(result).toEqual({});
}); });
it("should handle middleware that returns a completely different object", async () => { it('should handle middleware that returns a completely different object', async () => {
const chain = createMiddlewareChain<{ x: number }, { y: string }>( const chain = createMiddlewareChain<{ x: number }, { y: string }>(
async () => ({ y: "default" }), async () => ({ y: 'default' })
); );
chain.use(async (_ctx, next) => { chain.use(async (_ctx, next) => {
@ -411,12 +403,12 @@ describe("createMiddlewareChain", () => {
const result = await chain.execute({ x: 42 }); const result = await chain.execute({ x: 42 });
expect(result).toEqual({ y: "default" }); expect(result).toEqual({ y: 'default' });
}); });
it("should handle middleware that mutates context without returning", async () => { it('should handle middleware that mutates context without returning', async () => {
const chain = createMiddlewareChain<{ value: number }>( const chain = createMiddlewareChain<{ value: number }>(
async (ctx) => ctx, async ctx => ctx
); );
chain.use(async (ctx, next) => { chain.use(async (ctx, next) => {
@ -429,12 +421,11 @@ describe("createMiddlewareChain", () => {
expect(result.value).toBe(100); expect(result.value).toBe(100);
}); });
it("should return undefined when middleware does not call next or return", async () => { it('should return undefined when middleware does not call next or return', async () => {
const chain = createMiddlewareChain<{ value: number }>(); const chain = createMiddlewareChain<{ value: number }>();
chain.use(async (ctx) => { chain.use(async (ctx) => {
ctx.value = 100; ctx.value = 100;
return undefined as unknown as { value: number };
}); });
const result = await chain.execute({ value: 0 }); const result = await chain.execute({ value: 0 });