\ No newline at end of file
diff --git a/src/components/Controls/ActionBar/Actions.svelte b/src/components/Controls/ActionBar/Actions.svelte
index 2fdaee54..a08a3bc1 100644
--- a/src/components/Controls/ActionBar/Actions.svelte
+++ b/src/components/Controls/ActionBar/Actions.svelte
@@ -1,77 +1,158 @@
\ No newline at end of file
diff --git a/src/components/Header/Dropdown.svelte b/src/components/Header/Dropdown.svelte
index c4d634d1..fa3e820a 100644
--- a/src/components/Header/Dropdown.svelte
+++ b/src/components/Header/Dropdown.svelte
@@ -1,142 +1,161 @@
\ No newline at end of file
diff --git a/src/components/Modal/Types/Welcome.svelte b/src/components/Modal/Types/Welcome.svelte
index 5076e372..cadb1e92 100644
--- a/src/components/Modal/Types/Welcome.svelte
+++ b/src/components/Modal/Types/Welcome.svelte
@@ -1,57 +1,73 @@
-
-
Start
+
+
欢迎来到数独
+
+
输入自定义题目（81位数字，0代表空格）
+
+
+ 例如：003020600900305001001806400008102900700000008006708200002609500800203009005010300
+
+
+
+ 选择难度
+
+ {#each Object.entries(DIFFICULTIES) as [key, label]}
+ {label}
+ {/each}
+
+
+
+
+ Start
+
+ 取消
+
\ No newline at end of file
diff --git a/src/components/Modal/Types/index.js b/src/components/Modal/Types/index.js
index 54b8810a..e4439c41 100644
--- a/src/components/Modal/Types/index.js
+++ b/src/components/Modal/Types/index.js
@@ -6,6 +6,11 @@ import prompt from './Prompt.svelte';
import welcome from './Welcome.svelte';
import gameover from './GameOver.svelte';
+
+
+
+
+
export default {
share,
qrcode,
diff --git a/src/node_modules/@sudoku/stores/grid.js b/src/node_modules/@sudoku/stores/grid.js
index f803807b..2edec307 100644
--- a/src/node_modules/@sudoku/stores/grid.js
+++ b/src/node_modules/@sudoku/stores/grid.js
@@ -5,37 +5,70 @@ import { derived, writable } from 'svelte/store';
import { hints } from './hints';
function createGrid() {
- const grid = writable([
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0],
- ]);
-
- return {
- subscribe: grid.subscribe,
-
- generate(difficulty) {
- grid.set(generateSudoku(difficulty));
- },
-
- decodeSencode(sencode) {
- grid.set(decodeSencode(sencode));
+ const grid = writable([
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ]);
+
+ return {
+ subscribe: grid.subscribe,
+
+ // 导入字符串方法（81位数字字符串）
+ // 该字符串应为0-9的数字，长度为81
+ importString(str) {
+ if (!str || str.length !== 81 || !/^[0-9]+$/.test(str)) {
+ return false;
+ }
+
+ try {
+ const puzzle = [];
+ // 将81位字符串转换为9x9数组
+ for (let i = 0; i < 9; i++) {
+ const row = [];
+ for (let j = 0; j < 9; j++) {
+ const value = parseInt(str[i * 9 + j]);
+ if (isNaN(value) || value < 0 || value > 9) {
+ return false;
+ }
+ row.push(value);
+ }
+ puzzle.push(row);
+ }
+
+ // 更新grid
+ grid.set(puzzle);
+ // 确保也更新 userGrid（用户填写的内容）
+ userGrid.set(puzzle.map(row => [...row]));
+ return true;
+ } catch (e) {
+ console.error('导入失败:', e);
+ return false;
+ }
+ },
+
+ generate(difficulty) {
+ grid.set(generateSudoku(difficulty));
+ },
+
+ decodeSencode(sencode) {
+ grid.set(decodeSencode(sencode));
+ },
+
+ get(gridStore, x, y) {
+ return gridStore[y][x];
+ },
+
+ getSencode(gridStore) {
+ return encodeSudoku(gridStore);
},
-
- get(gridStore, x, y) {
- return gridStore[y][x];
- },
-
- getSencode(gridStore) {
- return encodeSudoku(gridStore);
- },
- };
+ };
}
export const grid = createGrid();
diff --git a/src/node_modules/@sudoku/stores/hints.js b/src/node_modules/@sudoku/stores/hints.js
index 4b09e5a4..fa619b80 100644
--- a/src/node_modules/@sudoku/stores/hints.js
+++ b/src/node_modules/@sudoku/stores/hints.js
@@ -1,46 +1,435 @@
import { settings } from './settings';
import { writable } from 'svelte/store';
+import { SUDOKU_SIZE } from '../constants';
export const usedHints = writable(0);
function createHints() {
- let defaultHints = Infinity;
-
- const hints = writable(Infinity);
-
- settings.subscribe(($settings) => {
- if ($settings.hintsLimited) {
- defaultHints = $settings.hints;
- hints.update($hints => {
- if ($hints > $settings.hints) return $settings.hints;
-
- return $hints;
- })
- } else {
- defaultHints = Infinity;
- hints.set(Infinity);
- }
- });
-
- return {
- subscribe: hints.subscribe,
-
- useHint() {
- hints.update($hints => {
- if ($hints > 0) {
- usedHints.update($usedHints => $usedHints + 1);
- return $hints - 1;
- }
-
- return 0;
- });
- },
-
- reset() {
- hints.set(defaultHints);
- usedHints.set(0);
- }
- };
+ let defaultHints = Infinity;
+
+ const hints = writable(Infinity);
+
+ settings.subscribe(($settings) => {
+ if ($settings.hintsLimited) {
+ defaultHints = $settings.hints;
+ hints.update($hints => {
+ if ($hints > $settings.hints) return $settings.hints;
+
+ return $hints;
+ })
+ } else {
+ defaultHints = Infinity;
+ hints.set(Infinity);
+ }
+ });
+
+ return {
+ subscribe: hints.subscribe,
+
+ use() {
+ hints.update($hints => {
+ if ($hints > 0) {
+ usedHints.update($usedHints => $usedHints + 1);
+ return $hints - 1;
+ }
+
+ return 0;
+ });
+ },
+
+ reset() {
+ hints.set(defaultHints);
+ usedHints.set(0);
+ }
+ };
+}
+
+export const hints = createHints();
+
+// 策略库
+export const strategies = {
+ // 1. 基础策略 - 唯一数字法
+ singleCandidate: {
+ name: "唯一数字法",
+ description: "当一个格子只有一个可能的数字时使用",
+ check: (grid, x, y, candidates) => {
+ if (candidates.length === 1) {
+ return {
+ strategy: "singleCandidate",
+ value: candidates[0],
+ explanation: `在第${y + 1}行第${x + 1}列的格子中只能填入数字 ${candidates[0]}，因为其他数字都与已填数字冲突。`
+ };
+ }
+ return null;
+ }
+ },
+
+ // 2. 基础策略 - 唯一位置法
+ hiddenSingle: {
+ name: "唯一位置法",
+ description: "当某个数字在行、列或九宫格中只能放在一个位置时使用",
+ check: (grid, x, y, candidates, allCandidates) => {
+ for (const num of candidates) {
+ // 检查行
+ let uniqueInRow = true;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== x && grid[y][i] === 0) {
+ const key = `${i},${y}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInRow = false;
+ break;
+ }
+ }
+ }
+ if (uniqueInRow) {
+ return {
+ strategy: "hiddenSingle",
+ value: num,
+ explanation: `在第${y + 1}行中，数字 ${num} 只能放在第${x + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查列
+ let uniqueInCol = true;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== y && grid[i][x] === 0) {
+ const key = `${x},${i}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInCol = false;
+ break;
+ }
+ }
+ }
+ if (uniqueInCol) {
+ return {
+ strategy: "hiddenSingle",
+ value: num,
+ explanation: `在第${x + 1}列中，数字 ${num} 只能放在第${y + 1}行，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查九宫格
+ const boxStartX = Math.floor(x / 3) * 3;
+ const boxStartY = Math.floor(y / 3) * 3;
+ let uniqueInBox = true;
+ for (let i = 0; i < 3 && uniqueInBox; i++) {
+ for (let j = 0; j < 3; j++) {
+ const checkX = boxStartX + j;
+ const checkY = boxStartY + i;
+ if ((checkX !== x || checkY !== y) && grid[checkY][checkX] === 0) {
+ const key = `${checkX},${checkY}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInBox = false;
+ break;
+ }
+ }
+ }
+ }
+ if (uniqueInBox) {
+ return {
+ strategy: "hiddenSingle",
+ value: num,
+ explanation: `在第${Math.floor(y/3) + 1}宫中，数字 ${num} 只能放在第${y + 1}行第${x + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+ }
+ return null;
+ }
+ },
+
+ // 3. 中级策略 - 数对法
+ nakedPair: {
+ name: "数对法",
+ description: "当两个格子的候选数相同且只有两个数字时使用",
+ check: (grid, x, y, candidates, allCandidates) => {
+ if (candidates.length !== 2) return null;
+
+ // 检查行中的数对
+ let pairFoundInRow = false;
+ let pairX = -1;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== x && grid[y][i] === 0) {
+ const key = `${i},${y}`;
+ const otherCandidates = allCandidates[key] || [];
+ if (arraysEqual(candidates, otherCandidates)) {
+ pairFoundInRow = true;
+ pairX = i;
+ break;
+ }
+ }
+ }
+
+ if (pairFoundInRow) {
+ return {
+ strategy: "nakedPair",
+ value: null,
+ candidates: candidates,
+ explanation: `在第${y + 1}行的第${x + 1}列和第${pairX + 1}列找到数对 ${candidates.join(',')}，这意味着这两个数字只能出现在这两个格子中。`
+ };
+ }
+
+ return null;
+ }
+ }
+};
+
+// 工具函数
+function arraysEqual(a, b) {
+ if (a.length !== b.length) return false;
+ return a.every((val, index) => val === b[index]);
+}
+
+// 获取单元格的候选数字
+export function getCandidates(grid, x, y) {
+ if (grid[y][x] !== 0) return [];
+
+ const used = new Set();
+
+ // 检查行
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (grid[y][i] !== 0) used.add(grid[y][i]);
+ }
+
+ // 检查列
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (grid[i][x] !== 0) used.add(grid[i][x]);
+ }
+
+ // 检查九宫格
+ const boxX = Math.floor(x / 3) * 3;
+ const boxY = Math.floor(y / 3) * 3;
+ for (let i = 0; i < 3; i++) {
+ for (let j = 0; j < 3; j++) {
+ if (grid[boxY + i][boxX + j] !== 0) {
+ used.add(grid[boxY + i][boxX + j]);
+ }
+ }
+ }
+
+ return Array.from({length: SUDOKU_SIZE}, (_, i) => i + 1).filter(n => !used.has(n));
+}
+
+// 获取所有格子的候选数字
+export function getAllCandidates(grid) {
+ const allCandidates = {};
+ for (let y = 0; y < SUDOKU_SIZE; y++) {
+ for (let x = 0; x < SUDOKU_SIZE; x++) {
+ if (grid[y][x] === 0) {
+ allCandidates[`${x},${y}`] = getCandidates(grid, x, y);
+ }
+ }
+ }
+ return allCandidates;
+}
+
+// 查找候选值最少的格子（使之更完善）
+function findMinCandidatesCell(grid) {
+ const allCandidates = getAllCandidates(grid);
+ let bestX = null;
+ let bestY = null;
+ let minCandidates = 10;
+
+ for (let y = 0; y < SUDOKU_SIZE; y++) {
+ for (let x = 0; x < SUDOKU_SIZE; x++) {
+ if (grid[y][x] === 0) {
+ const candidates = allCandidates[`${x},${y}`] || [];
+ if (candidates.length > 0 && candidates.length < minCandidates) {
+ minCandidates = candidates.length;
+ bestX = x;
+ bestY = y;
+ }
+ }
+ }
+ }
+
+ if (bestX !== null) {
+ const candidates = allCandidates[`${bestX},${bestY}`];
+ return {
+ strategy: "candidates",
+ x: bestX,
+ y: bestY,
+ candidates: candidates,
+ explanation: `在第${bestY + 1}行第${bestX + 1}列的格子中可以填入的数字有：${candidates.join(', ')}\n\n这是候选值最少的格子，找到正确答案的可能性更高。`
+ };
+ }
+
+ // 如果所有格子都有数字，返回null
+ return null;
}
-export const hints = createHints();
\ No newline at end of file
+// 查找下一步提示
+export function findNextHint(grid, x, y) {
+ console.log('Finding hint for position:', x, y);
+ const allCandidates = getAllCandidates(grid);
+
+ // 如果指定了特定格子，先检查该格子
+ if (x !== null && y !== null && grid[y][x] === 0) {
+ const cellCandidates = allCandidates[`${x},${y}`] || [];
+ if (cellCandidates.length === 0) {
+ return null;
+ }
+
+ // 按策略优先级尝试求解
+ for (const [strategyName, strategy] of Object.entries(strategies)) {
+ const result = strategy.check(grid, x, y, cellCandidates, allCandidates);
+ if (result) {
+ console.log(`Strategy ${strategyName} found solution:`, result);
+ return {
+ ...result,
+ x,
+ y,
+ candidates: cellCandidates
+ };
+ }
+ }
+
+ // 如果没有找到确定的策略，返回候选数
+ return {
+ strategy: "candidates",
+ x,
+ y,
+ candidates: cellCandidates,
+ explanation: `在第${y + 1}行第${x + 1}列的格子中可以填入的数字有：${cellCandidates.join(', ')}\n\n请继续观察数字分布规律，尝试找出确定的答案。`
+ };
+ }
+
+ // 没有指定格子或指定格子已填，寻找可填入格子
+
+ // 步骤1：寻找唯一数字格子（只有一个候选值）
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ for (let j = 0; j < SUDOKU_SIZE; j++) {
+ if (grid[i][j] === 0) {
+ const candidates = allCandidates[`${j},${i}`] || [];
+ if (candidates.length === 1) {
+ return {
+ strategy: "singleCandidate",
+ x: j,
+ y: i,
+ value: candidates[0],
+ candidates: candidates,
+ explanation: `在第${i + 1}行第${j + 1}列的格子中只能填入数字 ${candidates[0]}，因为其他数字都与已填数字冲突。`
+ };
+ }
+ }
+ }
+ }
+
+ // 步骤2：寻找唯一位置
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ for (let j = 0; j < SUDOKU_SIZE; j++) {
+ if (grid[i][j] === 0) {
+ const candidates = allCandidates[`${j},${i}`] || [];
+
+ // 检查唯一位置
+ for (const num of candidates) {
+ // 检查行唯一性
+ let uniqueInRow = true;
+ for (let k = 0; k < SUDOKU_SIZE; k++) {
+ if (k !== j && grid[i][k] === 0) {
+ const key = `${k},${i}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInRow = false;
+ break;
+ }
+ }
+ }
+
+ if (uniqueInRow) {
+ return {
+ strategy: "hiddenSingle",
+ x: j,
+ y: i,
+ value: num,
+ candidates: candidates,
+ explanation: `在第${i + 1}行中，数字 ${num} 只能放在第${j + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查列唯一性
+ let uniqueInCol = true;
+ for (let k = 0; k < SUDOKU_SIZE; k++) {
+ if (k !== i && grid[k][j] === 0) {
+ const key = `${j},${k}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInCol = false;
+ break;
+ }
+ }
+ }
+
+ if (uniqueInCol) {
+ return {
+ strategy: "hiddenSingle",
+ x: j,
+ y: i,
+ value: num,
+ candidates: candidates,
+ explanation: `在第${j + 1}列中，数字 ${num} 只能放在第${i + 1}行，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查九宫格唯一性
+ const boxStartX = Math.floor(j / 3) * 3;
+ const boxStartY = Math.floor(i / 3) * 3;
+ let uniqueInBox = true;
+
+ for (let r = 0; r < 3 && uniqueInBox; r++) {
+ for (let c = 0; c < 3; c++) {
+ const checkX = boxStartX + c;
+ const checkY = boxStartY + r;
+ if ((checkX !== j || checkY !== i) && grid[checkY][checkX] === 0) {
+ const key = `${checkX},${checkY}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInBox = false;
+ break;
+ }
+ }
+ }
+ }
+
+ if (uniqueInBox) {
+ return {
+ strategy: "hiddenSingle",
+ x: j,
+ y: i,
+ value: num,
+ candidates: candidates,
+ explanation: `在第${Math.floor(i/3) + 1}宫中，数字 ${num} 只能放在第${i + 1}行第${j + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+ }
+
+ // 检查数对
+ if (candidates.length === 2) {
+ // 检查行中的数对
+ let pairFoundInRow = false;
+ let pairX = -1;
+ for (let k = 0; k < SUDOKU_SIZE; k++) {
+ if (k !== j && grid[i][k] === 0) {
+ const key = `${k},${i}`;
+ const otherCandidates = allCandidates[key] || [];
+ if (arraysEqual(candidates, otherCandidates)) {
+ pairFoundInRow = true;
+ pairX = k;
+ break;
+ }
+ }
+ }
+
+ if (pairFoundInRow) {
+ return {
+ strategy: "nakedPair",
+ x: j,
+ y: i,
+ candidates: candidates,
+ explanation: `在第${i + 1}行的第${j + 1}列和第${pairX + 1}列找到数对 ${candidates.join(',')}，这意味着这两个数字只能出现在这两个格子中。`
+ };
+ }
+ }
+ }
+ }
+ }
+
+ // 步骤3：如果没有找到确定的策略，返回候选值最少的格子
+ return findMinCandidatesCell(grid);
+}
\ No newline at end of file
diff --git a/src/sudoku/constants.js b/src/sudoku/constants.js
new file mode 100644
index 00000000..9f9ae36c
--- /dev/null
+++ b/src/sudoku/constants.js
@@ -0,0 +1,49 @@
+export const BASE_URL = 'https://sudoku.jonasgeiler.com/';
+
+export const DIFFICULTY_CUSTOM = 'custom';
+export const DIFFICULTIES = {
+ veryeasy: 'Very Easy',
+ easy: 'Easy',
+ medium: 'Medium',
+ hard: 'Hard',
+};
+
+export const DEFAULT_SETTINGS = {
+ darkTheme: false,
+ displayTimer: true,
+ hintsLimited: true,
+ hints: 5,
+ highlightCells: true,
+ highlightSame: true,
+ highlightConflicting: true,
+};
+export const MAX_HINTS = 99999;
+
+export const SUDOKU_SIZE = 9;
+export const BOX_SIZE = 3;
+export const GRID_LENGTH = SUDOKU_SIZE * SUDOKU_SIZE;
+export const GRID_COORDS = [[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],[3,8],[4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],[4,8],[5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],[5,8],[6,0],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],[6,8],[7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7],[7,8],[8,0],[8,1],[8,2],[8,3],[8,4],[8,5],[8,6],[8,7],[8,8]];
+export const CANDIDATE_COORDS = [[1, 1],[1, 2],[1, 3],[2, 1],[2, 2],[2, 3],[3, 1],[3, 2],[3, 3]];
+
+export const SENCODE_SEPARATOR = '-';
+export const SENCODE_SEPARATOR_REVERSE = '_';
+export const SENCODE_REGEX = new RegExp('^[a-zA-Z0-9]+[' + SENCODE_SEPARATOR + SENCODE_SEPARATOR_REVERSE + '][a-zA-Z0-9]+$');
+
+export const BASE62_CHARSET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+export const MODAL_NONE = 'none'; // Modal type when hidden
+export const MODAL_DURATION = 400;
+
+export const DROPDOWN_DURATION = MODAL_DURATION;
+
+export const GAME_OVER_CELEBRATIONS = [
+ 'Excellent!',
+ 'Wow!',
+ 'Congratulations!',
+ 'Oh yeah!',
+ 'Impressive!',
+ 'Good work!',
+ 'You did great!',
+ 'Applause!',
+ 'Great!'
+]
\ No newline at end of file
diff --git a/src/sudoku/game.js b/src/sudoku/game.js
new file mode 100644
index 00000000..16d1226e
--- /dev/null
+++ b/src/sudoku/game.js
@@ -0,0 +1,57 @@
+import { cursor } from './stores/cursor';
+import { difficulty } from './stores/difficulty';
+import { gamePaused } from './stores/game';
+import { grid } from './stores/grid';
+import { timer } from './stores/timer';
+import { hints } from './stores/hints';
+
+/**
+ * Start new game with a generated sudoku
+ *
+ * @param {('veryeasy' | 'easy' | 'medium' | 'hard')} diff - Difficulty
+ */
+export function startNew(diff) {
+ difficulty.set(diff);
+ grid.generate(diff);
+ cursor.reset();
+ timer.reset();
+ hints.reset();
+
+ location.hash = '';
+}
+
+/**
+ * Start new game with a custom sudoku
+ *
+ * @param {string} sencode - Sencode to decode
+ */
+export function startCustom(sencode) {
+ difficulty.setCustom();
+ grid.decodeSencode(sencode);
+ cursor.reset();
+ timer.reset();
+ hints.reset();
+}
+
+/**
+ * Pause the game
+ */
+export function pauseGame() {
+ timer.stop();
+ gamePaused.set(true);
+}
+
+/**
+ * Resume (un-pause) the game
+ */
+export function resumeGame() {
+ timer.start();
+ gamePaused.set(false);
+}
+
+export default {
+ startNew,
+ startCustom,
+ pause: pauseGame,
+ resume: resumeGame
+};
\ No newline at end of file
diff --git a/src/sudoku/sencode/base62.js b/src/sudoku/sencode/base62.js
new file mode 100644
index 00000000..a911b675
--- /dev/null
+++ b/src/sudoku/sencode/base62.js
@@ -0,0 +1,34 @@
+import { BASE62_CHARSET as CHARSET } from '@sudoku/constants';
+
+export default class Base62 {
+ /**
+ * @param {BigInt} bigInt
+ * @returns {string}
+ */
+ static encode(bigInt) {
+ let base = BigInt(CHARSET.length);
+ let result = '';
+
+ while (0 < bigInt) {
+ result = CHARSET.charAt(Number(bigInt % base)) + result;
+ bigInt = bigInt / base;
+ }
+
+ return result || '0';
+ }
+
+ /**
+ * @param {string} base62
+ * @returns {BigInt}
+ */
+ static decode(base62) {
+ let base = BigInt(CHARSET.length);
+ let result = 0n;
+
+ for (let i = 0; i < base62.length; i++) {
+ result = result * base + BigInt(CHARSET.indexOf(base62[i]));
+ }
+
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/src/sudoku/sencode/index.js b/src/sudoku/sencode/index.js
new file mode 100644
index 00000000..d12c770c
--- /dev/null
+++ b/src/sudoku/sencode/index.js
@@ -0,0 +1,112 @@
+import { GRID_COORDS, GRID_LENGTH, SENCODE_REGEX, SENCODE_SEPARATOR as SEPARATOR, SENCODE_SEPARATOR_REVERSE as SEPARATOR_REVERSE } from '@sudoku/constants';
+import Base62 from './base62';
+
+
+/**
+ * @param {number[]} flatGrid
+ * @returns {boolean}
+ */
+function shouldReverse(flatGrid) {
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ if (flatGrid[(GRID_LENGTH - 1) - cell] !== 0) {
+ return false;
+ } else if (flatGrid[cell] !== 0) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+/**
+ * @param {number[][]} sudoku
+ * @returns {string}
+ */
+export function encodeSudoku(sudoku) {
+ /** @type number[] */
+ const flatGrid = sudoku.flat();
+
+ const reversed = shouldReverse(flatGrid);
+ if (reversed) {
+ // Reverse sudoku array
+ flatGrid.reverse();
+ }
+
+ let structure = '';
+ let numbers = '';
+
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ structure += (flatGrid[cell] === 0 ? '0' : '1');
+
+ if (flatGrid[cell] > 0) {
+ numbers += flatGrid[cell] - 1; // Subtract 1 so the number gets smaller
+ }
+ }
+
+ return Base62.encode(BigInt('0b' + structure)) +
+ (reversed ? SEPARATOR_REVERSE : SEPARATOR) +
+ Base62.encode(BigInt(numbers));
+}
+
+
+/**
+ * @param {string} sencode
+ * @returns {number[][]}
+ */
+export function decodeSencode(sencode) {
+ let grid = [
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ];
+
+ const reversed = sencode.indexOf(SEPARATOR_REVERSE) !== -1;
+
+ const [encodedStructure, encodedNumbers] = sencode.split(reversed ? SEPARATOR_REVERSE : SEPARATOR);
+
+ const structure = Base62.decode(encodedStructure)
+ .toString(2)
+ .padStart(GRID_LENGTH, '0');
+
+ let numberCount = 0;
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ if (structure[cell] === '1') {
+ numberCount++;
+ }
+ }
+
+ let numbers = Base62.decode(encodedNumbers)
+ .toString()
+ .padStart(numberCount, '0')
+ .split('');
+
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ if (structure[cell] === '1') {
+ const [row, col] = GRID_COORDS[cell];
+ grid[row][col] = numbers.shift() * 1 + 1;
+ }
+ }
+
+ if (reversed) {
+ // Reverse Grid
+ grid = grid.reverse().map(row => row.reverse());
+ }
+
+ return grid;
+}
+
+
+/**
+ * @param {string} sencode
+ * @returns {boolean}
+ */
+export function validateSencode(sencode) {
+ return sencode && sencode.trim().length !== 0 && SENCODE_REGEX.test(sencode);
+}
\ No newline at end of file
diff --git a/src/sudoku/stores/candidates.js b/src/sudoku/stores/candidates.js
new file mode 100644
index 00000000..95dc15eb
--- /dev/null
+++ b/src/sudoku/stores/candidates.js
@@ -0,0 +1,32 @@
+import { writable } from 'svelte/store';
+
+function createCandidates() {
+ const candidates = writable({});
+
+ return {
+ subscribe: candidates.subscribe,
+
+ add(pos, candidate) {
+ candidates.update($candidates => {
+ if (!$candidates.hasOwnProperty(pos.x + ',' + pos.y)) {
+ $candidates[pos.x + ',' + pos.y] = [candidate];
+ } else if ($candidates[pos.x + ',' + pos.y].includes(candidate)) {
+ delete $candidates[pos.x + ',' + pos.y][$candidates[pos.x + ',' + pos.y].indexOf(candidate)];
+ } else {
+ $candidates[pos.x + ',' + pos.y].push(candidate);
+ }
+
+ return $candidates;
+ });
+ },
+
+ clear(pos) {
+ candidates.update($candidates => {
+ delete $candidates[pos.x + ',' + pos.y];
+ return $candidates;
+ });
+ }
+ }
+}
+
+export const candidates = createCandidates();
\ No newline at end of file
diff --git a/src/sudoku/stores/cursor.js b/src/sudoku/stores/cursor.js
new file mode 100644
index 00000000..9934e36f
--- /dev/null
+++ b/src/sudoku/stores/cursor.js
@@ -0,0 +1,37 @@
+import { SUDOKU_SIZE } from '@sudoku/constants';
+import { writable } from 'svelte/store';
+
+function createCursor() {
+ const cursor = writable({ x: null, y: null });
+
+ return {
+ subscribe: cursor.subscribe,
+
+ set(x, y) {
+ cursor.set({ x, y });
+ },
+
+ move(xDir = 0, yDir = 0) {
+ cursor.update($cursor => {
+ let newX = $cursor.x + xDir;
+ let newY = $cursor.y + yDir;
+
+ if (newX < 0) newX = SUDOKU_SIZE - 1;
+ if (newX >= SUDOKU_SIZE) newX = 0;
+ if (newY < 0) newY = SUDOKU_SIZE - 1;
+ if (newY >= SUDOKU_SIZE) newY = 0;
+
+ return {
+ x: newX,
+ y: newY,
+ };
+ });
+ },
+
+ reset() {
+ this.set(null, null);
+ }
+ };
+}
+
+export const cursor = createCursor();
\ No newline at end of file
diff --git a/src/sudoku/stores/difficulty.js b/src/sudoku/stores/difficulty.js
new file mode 100644
index 00000000..72adab93
--- /dev/null
+++ b/src/sudoku/stores/difficulty.js
@@ -0,0 +1,31 @@
+import { DIFFICULTIES, DIFFICULTY_CUSTOM } from '@sudoku/constants';
+import { writable } from 'svelte/store';
+
+function createDifficulty() {
+ const difficulty = writable((() => {
+ const storedDifficulty = localStorage.getItem('difficulty');
+
+ if (DIFFICULTIES.hasOwnProperty(storedDifficulty)) {
+ return storedDifficulty;
+ }
+
+ return Object.keys(DIFFICULTIES)[0];
+ })());
+
+ return {
+ subscribe: difficulty.subscribe,
+
+ set(newDifficulty) {
+ if (DIFFICULTIES.hasOwnProperty(newDifficulty)) {
+ difficulty.set(newDifficulty);
+ localStorage.setItem('difficulty', newDifficulty);
+ }
+ },
+
+ setCustom() {
+ difficulty.set(DIFFICULTY_CUSTOM);
+ }
+ };
+}
+
+export const difficulty = createDifficulty();
\ No newline at end of file
diff --git a/src/sudoku/stores/game.js b/src/sudoku/stores/game.js
new file mode 100644
index 00000000..702d97ad
--- /dev/null
+++ b/src/sudoku/stores/game.js
@@ -0,0 +1,20 @@
+import { invalidCells, userGrid } from './grid';
+import { SUDOKU_SIZE } from '@sudoku/constants';
+import { derived, writable } from 'svelte/store';
+
+export const gamePaused = writable(true);
+
+export const gameWon = derived(
+ [userGrid, invalidCells],
+ ([$userGrid, $invalidCells]) => {
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if ($userGrid[row][col] === 0) return false;
+ }
+ }
+ // No empty fields...
+
+ return ($invalidCells.length === 0);
+ },
+ false,
+);
\ No newline at end of file
diff --git a/src/sudoku/stores/grid.js b/src/sudoku/stores/grid.js
new file mode 100644
index 00000000..2edec307
--- /dev/null
+++ b/src/sudoku/stores/grid.js
@@ -0,0 +1,170 @@
+import { BOX_SIZE, SUDOKU_SIZE } from '@sudoku/constants';
+import { decodeSencode, encodeSudoku } from '@sudoku/sencode';
+import { generateSudoku, solveSudoku } from '@sudoku/sudoku';
+import { derived, writable } from 'svelte/store';
+import { hints } from './hints';
+
+function createGrid() {
+ const grid = writable([
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ]);
+
+ return {
+ subscribe: grid.subscribe,
+
+ // 导入字符串方法（81位数字字符串）
+ // 该字符串应为0-9的数字，长度为81
+ importString(str) {
+ if (!str || str.length !== 81 || !/^[0-9]+$/.test(str)) {
+ return false;
+ }
+
+ try {
+ const puzzle = [];
+ // 将81位字符串转换为9x9数组
+ for (let i = 0; i < 9; i++) {
+ const row = [];
+ for (let j = 0; j < 9; j++) {
+ const value = parseInt(str[i * 9 + j]);
+ if (isNaN(value) || value < 0 || value > 9) {
+ return false;
+ }
+ row.push(value);
+ }
+ puzzle.push(row);
+ }
+
+ // 更新grid
+ grid.set(puzzle);
+ // 确保也更新 userGrid（用户填写的内容）
+ userGrid.set(puzzle.map(row => [...row]));
+ return true;
+ } catch (e) {
+ console.error('导入失败:', e);
+ return false;
+ }
+ },
+
+ generate(difficulty) {
+ grid.set(generateSudoku(difficulty));
+ },
+
+ decodeSencode(sencode) {
+ grid.set(decodeSencode(sencode));
+ },
+
+ get(gridStore, x, y) {
+ return gridStore[y][x];
+ },
+
+ getSencode(gridStore) {
+ return encodeSudoku(gridStore);
+ },
+ };
+}
+
+export const grid = createGrid();
+
+
+function createUserGrid() {
+ const userGrid = writable([
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ]);
+
+ grid.subscribe($grid => {
+ let newGrid = [];
+
+ for (let y = 0; y < SUDOKU_SIZE; y++) {
+ newGrid[y] = [];
+ for (let x = 0; x < SUDOKU_SIZE; x++) {
+ newGrid[y][x] = $grid[y][x];
+ }
+ }
+
+ userGrid.set(newGrid);
+ });
+
+ return {
+ subscribe: userGrid.subscribe,
+
+ set: (pos, value) => {
+ userGrid.update($userGrid => {
+ $userGrid[pos.y][pos.x] = value;
+ return $userGrid;
+ });
+ },
+
+ applyHint: (pos) => {
+ hints.useHint();
+ userGrid.update($userGrid => {
+ const solvedSudoku = solveSudoku($userGrid);
+ $userGrid[pos.y][pos.x] = solvedSudoku[pos.y][pos.x];
+ return $userGrid;
+ });
+ },
+ };
+}
+
+export const userGrid = createUserGrid();
+
+export const invalidCells = derived(userGrid, $userGrid => {
+ const _invalidCells = [];
+
+ const addInvalid = (x, y) => {
+ const xy = x + ',' + y;
+ if (!_invalidCells.includes(xy)) _invalidCells.push(xy);
+ };
+
+ for (let y = 0; y < SUDOKU_SIZE; y++) {
+ for (let x = 0; x < SUDOKU_SIZE; x++) {
+
+ const value = $userGrid[y][x];
+
+ if (value) {
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ // Check the row
+ if (i !== x && $userGrid[y][i] === value) {
+ addInvalid(x, y);
+ }
+
+ // Check the column
+ if (i !== y && $userGrid[i][x] === value) {
+ addInvalid(x, i);
+ }
+ }
+
+ // Check the box
+ const startY = Math.floor(y / BOX_SIZE) * BOX_SIZE;
+ const endY = startY + BOX_SIZE;
+ const startX = Math.floor(x / BOX_SIZE) * BOX_SIZE;
+ const endX = startX + BOX_SIZE;
+ for (let row = startY; row < endY; row++) {
+ for (let col = startX; col < endX; col++) {
+ if (row !== y && col !== x && $userGrid[row][col] === value) {
+ addInvalid(col, row);
+ }
+ }
+ }
+ }
+
+ }
+ }
+
+ return _invalidCells;
+}, []);
\ No newline at end of file
diff --git a/src/sudoku/stores/hints.js b/src/sudoku/stores/hints.js
new file mode 100644
index 00000000..fa619b80
--- /dev/null
+++ b/src/sudoku/stores/hints.js
@@ -0,0 +1,435 @@
+import { settings } from './settings';
+import { writable } from 'svelte/store';
+import { SUDOKU_SIZE } from '../constants';
+
+export const usedHints = writable(0);
+
+function createHints() {
+ let defaultHints = Infinity;
+
+ const hints = writable(Infinity);
+
+ settings.subscribe(($settings) => {
+ if ($settings.hintsLimited) {
+ defaultHints = $settings.hints;
+ hints.update($hints => {
+ if ($hints > $settings.hints) return $settings.hints;
+
+ return $hints;
+ })
+ } else {
+ defaultHints = Infinity;
+ hints.set(Infinity);
+ }
+ });
+
+ return {
+ subscribe: hints.subscribe,
+
+ use() {
+ hints.update($hints => {
+ if ($hints > 0) {
+ usedHints.update($usedHints => $usedHints + 1);
+ return $hints - 1;
+ }
+
+ return 0;
+ });
+ },
+
+ reset() {
+ hints.set(defaultHints);
+ usedHints.set(0);
+ }
+ };
+}
+
+export const hints = createHints();
+
+// 策略库
+export const strategies = {
+ // 1. 基础策略 - 唯一数字法
+ singleCandidate: {
+ name: "唯一数字法",
+ description: "当一个格子只有一个可能的数字时使用",
+ check: (grid, x, y, candidates) => {
+ if (candidates.length === 1) {
+ return {
+ strategy: "singleCandidate",
+ value: candidates[0],
+ explanation: `在第${y + 1}行第${x + 1}列的格子中只能填入数字 ${candidates[0]}，因为其他数字都与已填数字冲突。`
+ };
+ }
+ return null;
+ }
+ },
+
+ // 2. 基础策略 - 唯一位置法
+ hiddenSingle: {
+ name: "唯一位置法",
+ description: "当某个数字在行、列或九宫格中只能放在一个位置时使用",
+ check: (grid, x, y, candidates, allCandidates) => {
+ for (const num of candidates) {
+ // 检查行
+ let uniqueInRow = true;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== x && grid[y][i] === 0) {
+ const key = `${i},${y}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInRow = false;
+ break;
+ }
+ }
+ }
+ if (uniqueInRow) {
+ return {
+ strategy: "hiddenSingle",
+ value: num,
+ explanation: `在第${y + 1}行中，数字 ${num} 只能放在第${x + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查列
+ let uniqueInCol = true;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== y && grid[i][x] === 0) {
+ const key = `${x},${i}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInCol = false;
+ break;
+ }
+ }
+ }
+ if (uniqueInCol) {
+ return {
+ strategy: "hiddenSingle",
+ value: num,
+ explanation: `在第${x + 1}列中，数字 ${num} 只能放在第${y + 1}行，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查九宫格
+ const boxStartX = Math.floor(x / 3) * 3;
+ const boxStartY = Math.floor(y / 3) * 3;
+ let uniqueInBox = true;
+ for (let i = 0; i < 3 && uniqueInBox; i++) {
+ for (let j = 0; j < 3; j++) {
+ const checkX = boxStartX + j;
+ const checkY = boxStartY + i;
+ if ((checkX !== x || checkY !== y) && grid[checkY][checkX] === 0) {
+ const key = `${checkX},${checkY}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInBox = false;
+ break;
+ }
+ }
+ }
+ }
+ if (uniqueInBox) {
+ return {
+ strategy: "hiddenSingle",
+ value: num,
+ explanation: `在第${Math.floor(y/3) + 1}宫中，数字 ${num} 只能放在第${y + 1}行第${x + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+ }
+ return null;
+ }
+ },
+
+ // 3. 中级策略 - 数对法
+ nakedPair: {
+ name: "数对法",
+ description: "当两个格子的候选数相同且只有两个数字时使用",
+ check: (grid, x, y, candidates, allCandidates) => {
+ if (candidates.length !== 2) return null;
+
+ // 检查行中的数对
+ let pairFoundInRow = false;
+ let pairX = -1;
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (i !== x && grid[y][i] === 0) {
+ const key = `${i},${y}`;
+ const otherCandidates = allCandidates[key] || [];
+ if (arraysEqual(candidates, otherCandidates)) {
+ pairFoundInRow = true;
+ pairX = i;
+ break;
+ }
+ }
+ }
+
+ if (pairFoundInRow) {
+ return {
+ strategy: "nakedPair",
+ value: null,
+ candidates: candidates,
+ explanation: `在第${y + 1}行的第${x + 1}列和第${pairX + 1}列找到数对 ${candidates.join(',')}，这意味着这两个数字只能出现在这两个格子中。`
+ };
+ }
+
+ return null;
+ }
+ }
+};
+
+// 工具函数
+function arraysEqual(a, b) {
+ if (a.length !== b.length) return false;
+ return a.every((val, index) => val === b[index]);
+}
+
+// 获取单元格的候选数字
+export function getCandidates(grid, x, y) {
+ if (grid[y][x] !== 0) return [];
+
+ const used = new Set();
+
+ // 检查行
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (grid[y][i] !== 0) used.add(grid[y][i]);
+ }
+
+ // 检查列
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ if (grid[i][x] !== 0) used.add(grid[i][x]);
+ }
+
+ // 检查九宫格
+ const boxX = Math.floor(x / 3) * 3;
+ const boxY = Math.floor(y / 3) * 3;
+ for (let i = 0; i < 3; i++) {
+ for (let j = 0; j < 3; j++) {
+ if (grid[boxY + i][boxX + j] !== 0) {
+ used.add(grid[boxY + i][boxX + j]);
+ }
+ }
+ }
+
+ return Array.from({length: SUDOKU_SIZE}, (_, i) => i + 1).filter(n => !used.has(n));
+}
+
+// 获取所有格子的候选数字
+export function getAllCandidates(grid) {
+ const allCandidates = {};
+ for (let y = 0; y < SUDOKU_SIZE; y++) {
+ for (let x = 0; x < SUDOKU_SIZE; x++) {
+ if (grid[y][x] === 0) {
+ allCandidates[`${x},${y}`] = getCandidates(grid, x, y);
+ }
+ }
+ }
+ return allCandidates;
+}
+
+// 查找候选值最少的格子（使之更完善）
+function findMinCandidatesCell(grid) {
+ const allCandidates = getAllCandidates(grid);
+ let bestX = null;
+ let bestY = null;
+ let minCandidates = 10;
+
+ for (let y = 0; y < SUDOKU_SIZE; y++) {
+ for (let x = 0; x < SUDOKU_SIZE; x++) {
+ if (grid[y][x] === 0) {
+ const candidates = allCandidates[`${x},${y}`] || [];
+ if (candidates.length > 0 && candidates.length < minCandidates) {
+ minCandidates = candidates.length;
+ bestX = x;
+ bestY = y;
+ }
+ }
+ }
+ }
+
+ if (bestX !== null) {
+ const candidates = allCandidates[`${bestX},${bestY}`];
+ return {
+ strategy: "candidates",
+ x: bestX,
+ y: bestY,
+ candidates: candidates,
+ explanation: `在第${bestY + 1}行第${bestX + 1}列的格子中可以填入的数字有：${candidates.join(', ')}\n\n这是候选值最少的格子，找到正确答案的可能性更高。`
+ };
+ }
+
+ // 如果所有格子都有数字，返回null
+ return null;
+}
+
+// 查找下一步提示
+export function findNextHint(grid, x, y) {
+ console.log('Finding hint for position:', x, y);
+ const allCandidates = getAllCandidates(grid);
+
+ // 如果指定了特定格子，先检查该格子
+ if (x !== null && y !== null && grid[y][x] === 0) {
+ const cellCandidates = allCandidates[`${x},${y}`] || [];
+ if (cellCandidates.length === 0) {
+ return null;
+ }
+
+ // 按策略优先级尝试求解
+ for (const [strategyName, strategy] of Object.entries(strategies)) {
+ const result = strategy.check(grid, x, y, cellCandidates, allCandidates);
+ if (result) {
+ console.log(`Strategy ${strategyName} found solution:`, result);
+ return {
+ ...result,
+ x,
+ y,
+ candidates: cellCandidates
+ };
+ }
+ }
+
+ // 如果没有找到确定的策略，返回候选数
+ return {
+ strategy: "candidates",
+ x,
+ y,
+ candidates: cellCandidates,
+ explanation: `在第${y + 1}行第${x + 1}列的格子中可以填入的数字有：${cellCandidates.join(', ')}\n\n请继续观察数字分布规律，尝试找出确定的答案。`
+ };
+ }
+
+ // 没有指定格子或指定格子已填，寻找可填入格子
+
+ // 步骤1：寻找唯一数字格子（只有一个候选值）
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ for (let j = 0; j < SUDOKU_SIZE; j++) {
+ if (grid[i][j] === 0) {
+ const candidates = allCandidates[`${j},${i}`] || [];
+ if (candidates.length === 1) {
+ return {
+ strategy: "singleCandidate",
+ x: j,
+ y: i,
+ value: candidates[0],
+ candidates: candidates,
+ explanation: `在第${i + 1}行第${j + 1}列的格子中只能填入数字 ${candidates[0]}，因为其他数字都与已填数字冲突。`
+ };
+ }
+ }
+ }
+ }
+
+ // 步骤2：寻找唯一位置
+ for (let i = 0; i < SUDOKU_SIZE; i++) {
+ for (let j = 0; j < SUDOKU_SIZE; j++) {
+ if (grid[i][j] === 0) {
+ const candidates = allCandidates[`${j},${i}`] || [];
+
+ // 检查唯一位置
+ for (const num of candidates) {
+ // 检查行唯一性
+ let uniqueInRow = true;
+ for (let k = 0; k < SUDOKU_SIZE; k++) {
+ if (k !== j && grid[i][k] === 0) {
+ const key = `${k},${i}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInRow = false;
+ break;
+ }
+ }
+ }
+
+ if (uniqueInRow) {
+ return {
+ strategy: "hiddenSingle",
+ x: j,
+ y: i,
+ value: num,
+ candidates: candidates,
+ explanation: `在第${i + 1}行中，数字 ${num} 只能放在第${j + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查列唯一性
+ let uniqueInCol = true;
+ for (let k = 0; k < SUDOKU_SIZE; k++) {
+ if (k !== i && grid[k][j] === 0) {
+ const key = `${j},${k}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInCol = false;
+ break;
+ }
+ }
+ }
+
+ if (uniqueInCol) {
+ return {
+ strategy: "hiddenSingle",
+ x: j,
+ y: i,
+ value: num,
+ candidates: candidates,
+ explanation: `在第${j + 1}列中，数字 ${num} 只能放在第${i + 1}行，因为其他位置都不能填入该数字。`
+ };
+ }
+
+ // 检查九宫格唯一性
+ const boxStartX = Math.floor(j / 3) * 3;
+ const boxStartY = Math.floor(i / 3) * 3;
+ let uniqueInBox = true;
+
+ for (let r = 0; r < 3 && uniqueInBox; r++) {
+ for (let c = 0; c < 3; c++) {
+ const checkX = boxStartX + c;
+ const checkY = boxStartY + r;
+ if ((checkX !== j || checkY !== i) && grid[checkY][checkX] === 0) {
+ const key = `${checkX},${checkY}`;
+ if (allCandidates[key]?.includes(num)) {
+ uniqueInBox = false;
+ break;
+ }
+ }
+ }
+ }
+
+ if (uniqueInBox) {
+ return {
+ strategy: "hiddenSingle",
+ x: j,
+ y: i,
+ value: num,
+ candidates: candidates,
+ explanation: `在第${Math.floor(i/3) + 1}宫中，数字 ${num} 只能放在第${i + 1}行第${j + 1}列，因为其他位置都不能填入该数字。`
+ };
+ }
+ }
+
+ // 检查数对
+ if (candidates.length === 2) {
+ // 检查行中的数对
+ let pairFoundInRow = false;
+ let pairX = -1;
+ for (let k = 0; k < SUDOKU_SIZE; k++) {
+ if (k !== j && grid[i][k] === 0) {
+ const key = `${k},${i}`;
+ const otherCandidates = allCandidates[key] || [];
+ if (arraysEqual(candidates, otherCandidates)) {
+ pairFoundInRow = true;
+ pairX = k;
+ break;
+ }
+ }
+ }
+
+ if (pairFoundInRow) {
+ return {
+ strategy: "nakedPair",
+ x: j,
+ y: i,
+ candidates: candidates,
+ explanation: `在第${i + 1}行的第${j + 1}列和第${pairX + 1}列找到数对 ${candidates.join(',')}，这意味着这两个数字只能出现在这两个格子中。`
+ };
+ }
+ }
+ }
+ }
+ }
+
+ // 步骤3：如果没有找到确定的策略，返回候选值最少的格子
+ return findMinCandidatesCell(grid);
+}
\ No newline at end of file
diff --git a/src/sudoku/stores/keyboard.js b/src/sudoku/stores/keyboard.js
new file mode 100644
index 00000000..ee3ecacc
--- /dev/null
+++ b/src/sudoku/stores/keyboard.js
@@ -0,0 +1,12 @@
+import { cursor } from './cursor';
+import { gamePaused } from './game';
+import { grid } from './grid';
+import { derived } from 'svelte/store';
+
+export const keyboardDisabled = derived(
+ [cursor, grid, gamePaused],
+ ([$cursor, $grid, $gamePaused]) => {
+ return ($cursor.x === null && $cursor.y === null) || $grid[$cursor.y][$cursor.x] !== 0 || $gamePaused;
+ },
+ false,
+);
\ No newline at end of file
diff --git a/src/sudoku/stores/modal.js b/src/sudoku/stores/modal.js
new file mode 100644
index 00000000..d8b87680
--- /dev/null
+++ b/src/sudoku/stores/modal.js
@@ -0,0 +1,37 @@
+import { MODAL_DURATION, MODAL_NONE } from '@sudoku/constants';
+import { writable } from 'svelte/store';
+
+export const modalData = writable({});
+
+function createModal() {
+ const modalType = writable(MODAL_NONE);
+
+ let onHide = false;
+ let onHideReplace = false;
+
+ return {
+ subscribe: modalType.subscribe,
+
+ show(type, data = {}) {
+ modalType.set(type);
+ modalData.set(data);
+
+ onHide = data.onHide || false;
+ onHideReplace = data.onHideReplace || false;
+ },
+
+ hide() {
+ if (onHideReplace && onHide) {
+ onHide();
+ } else {
+ modalType.set(MODAL_NONE);
+
+ if (onHide) {
+ setTimeout(onHide, MODAL_DURATION);
+ }
+ }
+ },
+ };
+}
+
+export const modal = createModal();
\ No newline at end of file
diff --git a/src/sudoku/stores/notes.js b/src/sudoku/stores/notes.js
new file mode 100644
index 00000000..a7c15280
--- /dev/null
+++ b/src/sudoku/stores/notes.js
@@ -0,0 +1,15 @@
+import { writable } from 'svelte/store';
+
+function createNotes() {
+ const notes = writable(false);
+
+ return {
+ subscribe: notes.subscribe,
+
+ toggle() {
+ notes.update($notes => !$notes);
+ }
+ }
+}
+
+export const notes = createNotes();
\ No newline at end of file
diff --git a/src/sudoku/stores/settings.js b/src/sudoku/stores/settings.js
new file mode 100644
index 00000000..827668f7
--- /dev/null
+++ b/src/sudoku/stores/settings.js
@@ -0,0 +1,25 @@
+import { DEFAULT_SETTINGS } from '@sudoku/constants';
+import { writable } from 'svelte/store';
+
+function createSettings() {
+ const settings = writable((() => {
+ const storedSettings = localStorage.getItem('settings');
+
+ if (storedSettings) {
+ return JSON.parse(storedSettings);
+ }
+
+ return DEFAULT_SETTINGS;
+ })());
+
+ return {
+ subscribe: settings.subscribe,
+
+ set(newSettings) {
+ settings.set(newSettings);
+ localStorage.setItem('settings', JSON.stringify(newSettings));
+ },
+ };
+}
+
+export const settings = createSettings();
\ No newline at end of file
diff --git a/src/sudoku/stores/timer.js b/src/sudoku/stores/timer.js
new file mode 100644
index 00000000..67dc6d6c
--- /dev/null
+++ b/src/sudoku/stores/timer.js
@@ -0,0 +1,59 @@
+import { writable } from 'svelte/store';
+
+function createTimer() {
+ let timerInterval = null;
+ let timeBegan = null;
+ let timeStopped = null;
+ let stoppedDuration = 0;
+ let running = false;
+
+ const timer = writable('00:00');
+
+ // The timer uses a writable store but only returns a subscribe function so it's read-only
+ return {
+ subscribe: timer.subscribe,
+
+ start() {
+ if (running) return;
+
+ if (timeBegan === null) {
+ this.reset();
+ timeBegan = Date.now();
+ }
+
+ if (timeStopped !== null) {
+ stoppedDuration += (Date.now() - timeStopped);
+ }
+
+ timerInterval = setInterval(() => {
+ const time = Date.now() - timeBegan - stoppedDuration;
+ const timeStr = new Date(time).toISOString().substr(11, 8);
+
+ if (timeStr.substr(0, 2) === '00') {
+ timer.set(timeStr.substr(3));
+ return;
+ }
+
+ timer.set(timeStr);
+ }, 10);
+ running = true;
+ },
+
+ stop() {
+ running = false;
+ timeStopped = Date.now();
+ clearInterval(timerInterval);
+ },
+
+ reset() {
+ running = false;
+ clearInterval(timerInterval);
+ stoppedDuration = 0;
+ timeBegan = null;
+ timeStopped = null;
+ timer.set('00:00');
+ },
+ };
+}
+
+export const timer = createTimer();
\ No newline at end of file
diff --git a/src/sudoku/sudoku.js b/src/sudoku/sudoku.js
new file mode 100644
index 00000000..2a6cab4c
--- /dev/null
+++ b/src/sudoku/sudoku.js
@@ -0,0 +1,84 @@
+import solve from '@mattflow/sudoku-solver';
+import { BOX_SIZE, GRID_LENGTH, SUDOKU_SIZE, GRID_COORDS } from '@sudoku/constants';
+import { getSudoku } from 'fake-sudoku-puzzle-generator';
+
+
+/**
+ * @param {('veryeasy' | 'easy' | 'medium' | 'hard')} difficulty
+ * @returns {number[][]}
+ */
+export function generateSudoku(difficulty = 'easy') {
+ const sudoku = getSudoku(difficulty);
+
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if (sudoku[row][col] === null) sudoku[row][col] = 0;
+ }
+ }
+
+ return sudoku;
+}
+
+
+/**
+ * @param {number[][]} sudoku
+ */
+export function solveSudoku(sudoku) {
+ let grid = [
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ];
+
+ const solution = solve(sudoku.flat().join(''), {
+ outputArray: true,
+ hintCheck: false
+ });
+
+ for (let cell = 0; cell < GRID_LENGTH; cell++) {
+ const [row, col] = GRID_COORDS[cell];
+ grid[row][col] = solution[cell];
+ }
+
+ return grid;
+}
+
+
+/**
+ * @param {number[][]} sudoku
+ */
+export function printSudoku(sudoku) {
+ let out = '╔═══════╤═══════╤═══════╗\n';
+
+ for (let row = 0; row < SUDOKU_SIZE; row++) {
+ if (row !== 0 && row % BOX_SIZE === 0) {
+ out += '╟───────┼───────┼───────╢\n';
+ }
+
+ for (let col = 0; col < SUDOKU_SIZE; col++) {
+ if (col === 0) {
+ out += '║ ';
+ } else if (col % BOX_SIZE === 0) {
+ out += '│ ';
+ }
+
+ out += (sudoku[row][col] === 0 ? '·' : sudoku[row][col]) + ' ';
+
+ if (col === SUDOKU_SIZE - 1) {
+ out += '║';
+ }
+ }
+
+ out += '\n';
+ }
+
+ out += '╚═══════╧═══════╧═══════╝';
+
+ console.log(out);
+}
\ No newline at end of file
diff --git a/src/utils/candidateHelpers.js b/src/utils/candidateHelpers.js
new file mode 100644
index 00000000..6f51eba1
--- /dev/null
+++ b/src/utils/candidateHelpers.js
@@ -0,0 +1,33 @@
+import { candidates } from '@sudoku/stores/candidates';
+import { get } from 'svelte/store';
+
+// 扩展候选值功能
+export const setCandidates = (position, values) => {
+ // 获取当前候选值状态
+ const currentCandidates = get(candidates);
+
+ // 创建一个新的状态对象
+ const newCandidates = { ...currentCandidates };
+
+ // 设置新的候选值
+ const key = `${position.x},${position.y}`;
+ newCandidates[key] = values;
+
+ // 更新候选值状态
+ candidates.set(newCandidates);
+};
+
+export const clearCandidates = (position) => {
+ // 获取当前候选值状态
+ const currentCandidates = get(candidates);
+
+ // 创建一个新的状态对象
+ const newCandidates = { ...currentCandidates };
+
+ // 删除指定位置的候选值
+ const key = `${position.x},${position.y}`;
+ delete newCandidates[key];
+
+ // 更新候选值状态
+ candidates.set(newCandidates);
+};
\ No newline at end of file
diff --git a/svelte.config.js b/svelte.config.js
new file mode 100644
index 00000000..d7398a78
--- /dev/null
+++ b/svelte.config.js
@@ -0,0 +1,12 @@
+// svelte.config.js
+import sveltePreprocess from 'svelte-preprocess';
+
+export default {
+ preprocess: sveltePreprocess({
+ // 如果你需要 PostCSS，就保留这一行；不需要就设为 false
+ postcss: true,
+ // 其它预处理选项举例：
+ // scss: true,
+ // typescript: true,
+ })
+};
diff --git a/vite.config.js b/vite.config.js
new file mode 100644
index 00000000..39748530
--- /dev/null
+++ b/vite.config.js
@@ -0,0 +1,62 @@
+// vite.config.js
+import { defineConfig } from 'vite';
+import path from 'path';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import sveltePreprocess from 'svelte-preprocess';
+
+// 如果你还没有 svelte.config.js，可以直接在这里把预处理写好；
+// 否则你也可以把 preprocess 配置放到独立的 svelte.config.js 里，然后下面引用它
+const preprocess = sveltePreprocess({
+ // 启用 PostCSS 8
+ postcss: true,
+ // 根据需要启用其它预处理（如 SCSS、TypeScript 等）
+ // scss: true,
+ // typescript: true,
+});
+
+export default defineConfig({
+ plugins: [
+ svelte({
+ preprocess,
+ compilerOptions: {
+ // 强制生成 DOM 版本，避免 SSR 相关错误
+ generate: 'dom'
+ }
+ })
+ ],
+
+ resolve: {
+ alias: {
+ // 把 @sudoku 指向 src/sudoku 目录（把 @sudoku 包的源码移到这里）
+ '@sudoku': path.resolve(__dirname, 'src/sudoku')
+ }
+ },
+
+ test: {
+ globals: true,
+ environment: 'jsdom',
+ coverage: {
+ provider: 'v8',
+ reporter: ['text', 'lcov'],
+ reportsDirectory: 'coverage',
+ // 只统计 src/utils 下的 .js 业务代码
+ include: ['src/utils/**/*.js'],
+ // 排除非业务文件
+ exclude: [
+ 'node_modules/**',
+ 'scripts/**',
+ '**/*.config.js',
+ 'rollup.config.js',
+ 'tailwind.config.js',
+ 'src/main.js',
+ 'src/App.svelte',
+ 'src/components/**',
+ 'src/utils/candidateHelpers.js'
+ ],
+ // 覆盖率门槛
+ lines: 75,
+ functions: 80,
+ branches: 70
+ }
+ }
+});