GenarrativeAI/Genarrative
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
高物
2026-04-27 14:23:19 +08:00
parent 09d3fe59b3
commit fa2dbb310b
75 changed files with 7363 additions and 1487 deletions
Download Patch File Download Diff File Expand all files Collapse all files

234
src/services/puzzle-runtime/puzzleLocalRuntime.test.ts
View File

@@ -1,10 +1,12 @@
import { describe, expect, test } from 'vitest';
import type { PuzzlePieceState } from '../../../packages/shared/src/contracts/puzzleRuntimeSession';
import type { PuzzleWorkSummary } from '../../../packages/shared/src/contracts/puzzleWorkSummary';
import {
advanceLocalPuzzleLevel,
dragLocalPuzzlePiece,
startLocalPuzzleRun,
swapLocalPuzzlePieces,
} from './puzzleLocalRuntime';
const baseWork: PuzzleWorkSummary = {
@@ -25,6 +27,25 @@ const baseWork: PuzzleWorkSummary = {
publishReady: true,
};
function hasAnyCorrectNeighborPair(pieces: PuzzlePieceState[]) {
return pieces.some((piece) =>
pieces.some((candidate) => {
if (piece.pieceId === candidate.pieceId) {
return false;
}
const currentRowDelta = candidate.currentRow - piece.currentRow;
const currentColDelta = candidate.currentCol - piece.currentCol;
const correctRowDelta = candidate.correctRow - piece.correctRow;
const correctColDelta = candidate.correctCol - piece.correctCol;
return (
Math.abs(currentRowDelta) + Math.abs(currentColDelta) === 1 &&
currentRowDelta === correctRowDelta &&
currentColDelta === correctColDelta
);
}),
);
}
function solveCurrentLevel(run: ReturnType<typeof startLocalPuzzleRun>) {
let nextRun = run;
for (let index = 0; index < 12; index += 1) {
@@ -52,11 +73,222 @@ function solveCurrentLevel(run: ReturnType<typeof startLocalPuzzleRun>) {
}
describe('puzzleLocalRuntime', () => {
test('每次启动都会生成不同的初始打乱样式', async () => {
const firstRun = startLocalPuzzleRun(baseWork);
await new Promise((resolve) => setTimeout(resolve, 2));
const secondRun = startLocalPuzzleRun(baseWork);
const firstPositions = firstRun.currentLevel?.board.pieces.map((piece) => [
piece.currentRow,
piece.currentCol,
]);
const secondPositions = secondRun.currentLevel?.board.pieces.map((piece) => [
piece.currentRow,
piece.currentCol,
]);
expect(firstPositions).not.toEqual(secondPositions);
});
test('初始棋盘没有任何自动合并块', () => {
for (let index = 0; index < 12; index += 1) {
const run = startLocalPuzzleRun(baseWork);
const board = run.currentLevel?.board;
expect(board?.mergedGroups).toEqual([]);
expect(hasAnyCorrectNeighborPair(board?.pieces ?? [])).toBe(false);
}
});
test('交换后正确相邻的块会自动合并', () => {
const run = startLocalPuzzleRun(baseWork);
const board = run.currentLevel?.board;
expect(board).toBeTruthy();
if (!run.currentLevel || !board) {
return;
}
const nextRun = {
...run,
currentLevel: {
...run.currentLevel,
board: {
...board,
pieces: board.pieces.map((piece) => {
const layout: Record<string, [number, number]> = {
'piece-0': [1, 1],
'piece-1': [0, 1],
'piece-2': [2, 2],
'piece-3': [0, 2],
'piece-4': [1, 0],
'piece-5': [2, 0],
'piece-6': [0, 0],
'piece-7': [1, 2],
'piece-8': [2, 1],
};
const current = layout[piece.pieceId] ?? [piece.currentRow, piece.currentCol];
return {
...piece,
currentRow: current[0],
currentCol: current[1],
mergedGroupId: null,
};
}),
mergedGroups: [],
allTilesResolved: false,
},
},
};
const swapped = swapLocalPuzzlePieces(nextRun, {
firstPieceId: 'piece-0',
secondPieceId: 'piece-6',
});
expect(
swapped.currentLevel?.board.mergedGroups.some(
(group) =>
group.pieceIds.includes('piece-0') &&
group.pieceIds.includes('piece-1'),
),
).toBe(true);
});
test('全部拼块汇成一个大合并块后判定通关', () => {
const run = startLocalPuzzleRun(baseWork);
const board = run.currentLevel?.board;
expect(board).toBeTruthy();
if (!run.currentLevel || !board) {
return;
}
const solvedByOneGroup = {
...run,
currentLevel: {
...run.currentLevel,
board: {
...board,
pieces: board.pieces.map((piece, index) => ({
...piece,
currentRow: Math.floor(index / board.cols),
currentCol: (index + 1) % board.cols,
mergedGroupId: 'group-full',
})),
mergedGroups: [
{
groupId: 'group-full',
pieceIds: board.pieces.map((piece) => piece.pieceId),
occupiedCells: board.pieces.map((_, index) => ({
row: Math.floor(index / board.cols),
col: (index + 1) % board.cols,
})),
},
],
allTilesResolved: true,
},
},
};
expect(solvedByOneGroup.currentLevel.board.allTilesResolved).toBe(true);
});
test('大合并块覆盖多个小块时会与被覆盖块逐一交换，不会出现小块消失', () => {
const run = startLocalPuzzleRun(baseWork);
const board = run.currentLevel?.board;
expect(board).toBeTruthy();
if (!run.currentLevel || !board) {
return;
}
const preparedRun = {
...run,
currentLevel: {
...run.currentLevel,
board: {
...board,
pieces: board.pieces.map((piece) => {
const layout: Record<string, [number, number, string | null]> = {
'piece-0': [0, 0, 'group-1'],
'piece-1': [0, 1, 'group-1'],
'piece-2': [0, 2, null],
'piece-3': [1, 0, 'group-1'],
'piece-4': [1, 1, 'group-1'],
'piece-5': [1, 2, null],
'piece-6': [2, 0, null],
'piece-7': [2, 1, null],
'piece-8': [2, 2, null],
};
const current = layout[piece.pieceId] ?? [
piece.currentRow,
piece.currentCol,
piece.mergedGroupId,
];
return {
...piece,
currentRow: current[0],
currentCol: current[1],
mergedGroupId: current[2],
};
}),
mergedGroups: [
{
groupId: 'group-1',
pieceIds: ['piece-0', 'piece-1', 'piece-3', 'piece-4'],
occupiedCells: [
{ row: 0, col: 0 },
{ row: 0, col: 1 },
{ row: 1, col: 0 },
{ row: 1, col: 1 },
],
},
],
allTilesResolved: false,
},
},
};
const dragged = dragLocalPuzzlePiece(preparedRun, {
pieceId: 'piece-0',
targetRow: 1,
targetCol: 1,
});
const nextBoard = dragged.currentLevel?.board;
expect(nextBoard).toBeTruthy();
if (!nextBoard) {
return;
}
const occupiedCells = nextBoard.pieces.map((piece) => `${piece.currentRow}:${piece.currentCol}`);
expect(new Set(occupiedCells).size).toBe(nextBoard.pieces.length);
expect(
nextBoard.pieces.find((piece) => piece.pieceId === 'piece-5'),
).toMatchObject({ currentRow: 0, currentCol: 0 });
expect(
nextBoard.pieces.find((piece) => piece.pieceId === 'piece-7'),
).toMatchObject({ currentRow: 0, currentCol: 1 });
expect(
nextBoard.pieces.find((piece) => piece.pieceId === 'piece-8'),
).toMatchObject({ currentRow: 1, currentCol: 0 });
expect(
nextBoard.pieces.find((piece) => piece.pieceId === 'piece-0'),
).toMatchObject({ currentRow: 1, currentCol: 1 });
expect(
nextBoard.pieces.find((piece) => piece.pieceId === 'piece-4'),
).toMatchObject({ currentRow: 2, currentCol: 2 });
});
test('通关后提供下一关入口并能推进到新棋盘', () => {
const clearedRun = solveCurrentLevel(startLocalPuzzleRun(baseWork));
expect(clearedRun.currentLevel?.status).toBe('cleared');
expect(clearedRun.recommendedNextProfileId).toBe('profile-1::local-level-2');
expect(clearedRun.currentLevel?.elapsedMs).toBeGreaterThan(0);
expect(clearedRun.currentLevel?.leaderboardEntries.length).toBeGreaterThan(0);
expect(
clearedRun.currentLevel?.leaderboardEntries.some(
(entry) => entry.isCurrentPlayer && entry.nickname === '测试作者',
),
).toBe(true);
const nextRun = advanceLocalPuzzleLevel(clearedRun);
@@ -64,6 +296,8 @@ describe('puzzleLocalRuntime', () => {
expect(nextRun.currentLevel?.status).toBe('playing');
expect(nextRun.currentLevel?.levelName).toBe('测试拼图 · 第 2 关');
expect(nextRun.currentLevel?.board.allTilesResolved).toBe(false);
expect(nextRun.currentLevel?.elapsedMs).toBeNull();
expect(nextRun.currentLevel?.leaderboardEntries).toEqual([]);
expect(nextRun.recommendedNextProfileId).toBeNull();
});
});