@my-games/2048-core 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,13 +1,729 @@
+// src/board.ts
 /**
- * @my-games/2048-core
- *
- * 无框架依赖的 2048 引擎。三个入口：
- * - `Game2048` 类：状态机 + 订阅 + 存档 + 撤销。
- * - `bestMove` / `evaluate` / `simulateUntilEnd`：expectimax AI。
- * - 纯函数原语 `slideGrid` / `canMove` / `emptyCells` ...：给测试与自定义玩法用。
- */
-export { Game2048 } from './game';
-export { bestMove, evaluate, simulateUntilEnd } from './ai';
-export { canMove, cloneGrid, createEmptyGrid, emptyCells, gridsEqual, hasValue, maxValue, slideGrid, slideLineLeft } from './board';
-export { DEFAULT_BEST_KEY, DEFAULT_SAVE_KEY, SAVE_VERSION, clearSave, isSerializedSave, loadBest, loadSave, tryGetGlobalStorage, writeBest, writeSave } from './storage';
+* 纯函数棋盘工具：只用 `Cell[][]`（0 = 空），不涉及 tile id。
+*
+* 设计原则：所有会「改变棋盘」的函数都返回新数组，不原地修改。
+* Game2048 与 AI 都建立在这套底层原语上。
+*/
+function createEmptyGrid(size) {
+	return Array.from({ length: size }, () => Array(size).fill(0));
+}
+function cloneGrid(grid) {
+	return grid.map((row) => row.slice());
+}
+/** 生成所有空位坐标（row-major 顺序）。 */
+function emptyCells(grid) {
+	const out = [];
+	for (let r = 0; r < grid.length; r++) {
+		const row = grid[r];
+		if (!row) continue;
+		for (let c = 0; c < row.length; c++) if (row[c] === 0) out.push([r, c]);
+	}
+	return out;
+}
+/**
+* 把一行「向左压缩 + 相邻等值合并」。
+* 每个 tile 只允许在一次 slide 中参与一次合并，符合 2048 官方规则。
+* 返回：新 line（长度不变）+ 本行得分增量。
+*/
+function slideLineLeft(line) {
+	const source = line.filter((v) => v !== 0);
+	const result = [];
+	let gained = 0;
+	let i = 0;
+	while (i < source.length) {
+		const a = source[i];
+		const b = source[i + 1];
+		if (b !== void 0 && a === b) {
+			const merged = a * 2;
+			result.push(merged);
+			gained += merged;
+			i += 2;
+		} else {
+			result.push(a);
+			i += 1;
+		}
+	}
+	while (result.length < line.length) result.push(0);
+	return {
+		line: result,
+		gained
+	};
+}
+function reverseLine(line) {
+	return line.slice().reverse();
+}
+/** 沿方向向量把整个棋盘压缩一次；返回新 grid 与得分。 */
+function slideGrid(grid, dir) {
+	const size = grid.length;
+	const out = createEmptyGrid(size);
+	let gained = 0;
+	for (let k = 0; k < size; k++) {
+		const line = [];
+		for (let i = 0; i < size; i++) line.push(readCell(grid, dir, k, i));
+		const reversed = dir === "right" || dir === "down";
+		const { line: processed, gained: g } = slideLineLeft(reversed ? reverseLine(line) : line);
+		gained += g;
+		const output = reversed ? reverseLine(processed) : processed;
+		for (let i = 0; i < size; i++) writeCell(out, dir, k, i, output[i]);
+	}
+	return {
+		grid: out,
+		gained
+	};
+}
+/**
+* 将 (k=线序号, i=线内序号) 映射到具体 cell 坐标：
+* - left : row=k, col=i   （每行从左侧读）
+* - right: row=k, col=i   （读时按 i 反向由 slideGrid 处理）
+* - up   : row=i, col=k   （每列从上读）
+* - down : row=i, col=k
+* 注意：这里 readCell 只按「物理方向」取格子；反向压缩由 slideGrid 外面 reverseLine 承担。
+*/
+function readCell(grid, dir, k, i) {
+	switch (dir) {
+		case "left": return grid[k]?.[i] ?? 0;
+		case "right": return grid[k]?.[i] ?? 0;
+		case "up": return grid[i]?.[k] ?? 0;
+		case "down": return grid[i]?.[k] ?? 0;
+	}
+}
+function writeCell(grid, dir, k, i, v) {
+	switch (dir) {
+		case "left":
+		case "right":
+			{
+				const row = grid[k];
+				if (row) row[i] = v;
+			}
+			break;
+		case "up":
+		case "down": {
+			const row = grid[i];
+			if (row) row[k] = v;
+		}
+	}
+}
+function gridsEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let r = 0; r < a.length; r++) {
+		const ra = a[r];
+		const rb = b[r];
+		if (!ra || !rb) return false;
+		for (let c = 0; c < ra.length; c++) if (ra[c] !== rb[c]) return false;
+	}
+	return true;
+}
+/** 该方向是否有可移动的空间（含合并）。用于判定是否 game over。 */
+function canMove(grid) {
+	for (const d of [
+		"up",
+		"down",
+		"left",
+		"right"
+	]) {
+		const { grid: next } = slideGrid(grid, d);
+		if (!gridsEqual(grid, next)) return true;
+	}
+	return false;
+}
+/** 是否达到目标值（默认 2048）。 */
+function hasValue(grid, target) {
+	for (const row of grid) for (const v of row) if (v === target) return true;
+	return false;
+}
+/** 把值网格内的最大值取出来（调试用）。 */
+function maxValue(grid) {
+	let m = 0;
+	for (const row of grid) for (const v of row) if (v > m) m = v;
+	return m;
+}
+// src/storage.ts
+/**
+* 存档字段与版本控制。
+*
+* 版本演进策略：读到的 version 与当前 SAVE_VERSION 不一致时，走 `migrate()`；
+* 无法识别的直接丢弃并让 Game 开新局。目前只有 v1。
+*/
+var SAVE_VERSION = 1;
+var DEFAULT_SAVE_KEY = "game-2048:save";
+var DEFAULT_BEST_KEY = "game-2048:best";
+function isSerializedSave(x) {
+	if (typeof x !== "object" || x === null) return false;
+	const o = x;
+	return o["version"] === 1 && typeof o["size"] === "number" && Array.isArray(o["tiles"]) && typeof o["score"] === "number";
+}
+function loadSave(storage, key) {
+	if (!storage) return null;
+	const raw = storage.getItem(key);
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return isSerializedSave(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function writeSave(storage, key, save) {
+	if (!storage) return;
+	try {
+		storage.setItem(key, JSON.stringify(save));
+	} catch {}
+}
+function clearSave(storage, key) {
+	if (!storage) return;
+	try {
+		storage.removeItem(key);
+	} catch {}
+}
+function loadBest(storage, key) {
+	if (!storage) return 0;
+	const raw = storage.getItem(key);
+	if (!raw) return 0;
+	const n = Number(raw);
+	return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+function writeBest(storage, key, best) {
+	if (!storage) return;
+	try {
+		storage.setItem(key, String(Math.floor(best)));
+	} catch {}
+}
+/** 浏览器环境下的默认 Storage（找不到返回 null，让 core 在无 DOM 环境也能跑）。 */
+function tryGetGlobalStorage() {
+	if (typeof globalThis === "undefined") return null;
+	return globalThis.localStorage ?? null;
+}
+// src/game.ts
+var DEFAULT_SIZE = 4;
+var DEFAULT_TARGET = 2048;
+var DEFAULT_UNDO_LIMIT = 20;
+var CURSORS = {
+	left: {
+		start: (k) => ({
+			r: k,
+			c: 0
+		}),
+		step: {
+			dr: 0,
+			dc: 1
+		}
+	},
+	right: {
+		start: (k, size) => ({
+			r: k,
+			c: size - 1
+		}),
+		step: {
+			dr: 0,
+			dc: -1
+		}
+	},
+	up: {
+		start: (k) => ({
+			r: 0,
+			c: k
+		}),
+		step: {
+			dr: 1,
+			dc: 0
+		}
+	},
+	down: {
+		start: (k, size) => ({
+			r: size - 1,
+			c: k
+		}),
+		step: {
+			dr: -1,
+			dc: 0
+		}
+	}
+};
+function makeGrid(size) {
+	return Array.from({ length: size }, () => Array(size).fill(null));
+}
+var Game2048 = class {
+	constructor(opts = {}) {
+		this.score = 0;
+		this.bestScore = 0;
+		this.status = "playing";
+		this.keepPlaying = false;
+		this.moveCount = 0;
+		this.nextTileId = 1;
+		this.history = [];
+		this.listeners = /* @__PURE__ */ new Set();
+		this.notifying = false;
+		this.size = opts.size ?? DEFAULT_SIZE;
+		this.target = opts.target ?? DEFAULT_TARGET;
+		this.undoLimit = opts.undoLimit ?? DEFAULT_UNDO_LIMIT;
+		this.rng = opts.rng ?? Math.random;
+		this.storage = opts.storage === void 0 ? tryGetGlobalStorage() : opts.storage;
+		this.saveKey = opts.saveKey ?? "game-2048:save";
+		this.bestKey = opts.bestKey ?? "game-2048:best";
+		this.bestScore = loadBest(this.storage, this.bestKey);
+		this.grid = makeGrid(this.size);
+		const saved = opts.freshStart ? null : loadSave(this.storage, this.saveKey);
+		if (saved && saved.size === this.size) {
+			this.loadFromSave(saved);
+			if (!canMove(this.toValueGrid())) this.status = "lost";
+		} else this.startNewGame();
+	}
+	/** 订阅状态变化。返回退订函数。注册后立刻收到一次当前快照。 */
+	subscribe(fn) {
+		this.listeners.add(fn);
+		try {
+			fn(this.getState());
+		} catch (err) {
+			console.error("[game-2048] listener threw on subscribe:", err);
+		}
+		return () => {
+			this.listeners.delete(fn);
+		};
+	}
+	getState() {
+		return {
+			size: this.size,
+			tiles: this.collectTiles().map((t) => ({ ...t })),
+			score: this.score,
+			bestScore: this.bestScore,
+			status: this.status,
+			keepPlaying: this.keepPlaying,
+			moveCount: this.moveCount,
+			historySize: this.history.length
+		};
+	}
+	/** 拿到当前值网格（AI / 单测用）；不影响游戏内部。 */
+	getGridValues() {
+		return this.toValueGrid();
+	}
+	/** 是否还可以撤销。 */
+	canUndo() {
+		return this.history.length > 0;
+	}
+	/** 沿方向滑动一次。返回 true = 棋盘真的发生了变化；false = 该方向无解。 */
+	move(dir) {
+		if (this.status === "lost") return false;
+		if (this.status === "won" && !this.keepPlaying) return false;
+		const snap = this.takeSnapshot();
+		for (const row of this.grid) for (const t of row) if (t) {
+			t.isNew = false;
+			t.merged = false;
+		}
+		const { moved, gained } = this.executeSlide(dir);
+		if (!moved) return false;
+		this.score += gained;
+		this.pushHistory(snap);
+		this.moveCount += 1;
+		if (!this.keepPlaying && this.hasValueAtLeast(this.target)) this.status = "won";
+		this.spawnRandomTile();
+		if (!canMove(this.toValueGrid())) this.status = "lost";
+		this.commit();
+		return true;
+	}
+	/** 达到 2048 后用户点击「继续游戏」。 */
+	continuePlaying() {
+		if (this.status !== "won") return;
+		this.keepPlaying = true;
+		this.status = "playing";
+		this.commit();
+	}
+	/** 开启新局：清空 board + 重置 score；保留 bestScore。 */
+	newGame() {
+		this.startNewGame();
+		this.commit();
+	}
+	/** 撤销一步；返回是否成功（历史为空时 false）。 */
+	undo() {
+		const s = this.history.pop();
+		if (!s) return false;
+		this.restoreSnapshot(s);
+		this.commit();
+		return true;
+	}
+	/** 清除当前存档（不影响 bestScore）。 */
+	clearSaved() {
+		clearSave(this.storage, this.saveKey);
+	}
+	startNewGame() {
+		this.grid = makeGrid(this.size);
+		this.score = 0;
+		this.status = "playing";
+		this.keepPlaying = false;
+		this.moveCount = 0;
+		this.nextTileId = 1;
+		this.history = [];
+		this.spawnRandomTile();
+		this.spawnRandomTile();
+	}
+	spawnRandomTile() {
+		const empties = [];
+		for (let r = 0; r < this.size; r++) for (let c = 0; c < this.size; c++) if (!this.grid[r]?.[c]) empties.push([r, c]);
+		if (empties.length === 0) return;
+		const slot = empties[Math.min(empties.length - 1, Math.floor(this.rng() * empties.length))];
+		if (!slot) return;
+		const [r, c] = slot;
+		const value = this.rng() < .9 ? 2 : 4;
+		const tile = {
+			id: this.nextTileId++,
+			value,
+			row: r,
+			col: c,
+			isNew: true,
+			merged: false
+		};
+		const row = this.grid[r];
+		if (row) row[c] = tile;
+	}
+	executeSlide(dir) {
+		const cursors = CURSORS[dir];
+		let moved = false;
+		let gained = 0;
+		for (let k = 0; k < this.size; k++) {
+			const lineTiles = [];
+			const slotOfTile = /* @__PURE__ */ new Map();
+			for (let i = 0; i < this.size; i++) {
+				const { r, c } = this.cellAt(cursors, k, i);
+				const t = this.grid[r]?.[c];
+				if (t) {
+					lineTiles.push(t);
+					slotOfTile.set(t, i);
+				}
+			}
+			const result = [];
+			let idx = 0;
+			while (idx < lineTiles.length) {
+				const cur = lineTiles[idx];
+				const next = lineTiles[idx + 1];
+				if (!cur) break;
+				if (next && cur.value === next.value) {
+					cur.value *= 2;
+					cur.merged = true;
+					gained += cur.value;
+					result.push(cur);
+					idx += 2;
+					moved = true;
+				} else {
+					result.push(cur);
+					idx += 1;
+				}
+			}
+			for (let i = 0; i < result.length; i++) {
+				const t = result[i];
+				if (!t) continue;
+				if (slotOfTile.get(t) !== i) moved = true;
+			}
+			for (let i = 0; i < this.size; i++) {
+				const { r, c } = this.cellAt(cursors, k, i);
+				const row = this.grid[r];
+				if (row) row[c] = null;
+			}
+			for (let i = 0; i < result.length; i++) {
+				const t = result[i];
+				if (!t) continue;
+				const { r, c } = this.cellAt(cursors, k, i);
+				const row = this.grid[r];
+				if (row) row[c] = t;
+				t.row = r;
+				t.col = c;
+			}
+		}
+		return {
+			moved,
+			gained
+		};
+	}
+	cellAt(cursors, k, i) {
+		const start = cursors.start(k, this.size);
+		return {
+			r: start.r + i * cursors.step.dr,
+			c: start.c + i * cursors.step.dc
+		};
+	}
+	collectTiles() {
+		const out = [];
+		for (const row of this.grid) for (const t of row) if (t) out.push(t);
+		return out;
+	}
+	toValueGrid() {
+		const g = Array.from({ length: this.size }, () => Array(this.size).fill(0));
+		for (const t of this.collectTiles()) g[t.row][t.col] = t.value;
+		return g;
+	}
+	hasValueAtLeast(v) {
+		for (const t of this.collectTiles()) if (t.value >= v) return true;
+		return false;
+	}
+	takeSnapshot() {
+		return {
+			tiles: this.collectTiles().map((t) => ({ ...t })),
+			score: this.score,
+			status: this.status,
+			keepPlaying: this.keepPlaying,
+			moveCount: this.moveCount
+		};
+	}
+	restoreSnapshot(s) {
+		this.grid = makeGrid(this.size);
+		let maxId = 0;
+		for (const t of s.tiles) {
+			const clone = { ...t };
+			const row = this.grid[clone.row];
+			if (row) row[clone.col] = clone;
+			if (clone.id > maxId) maxId = clone.id;
+		}
+		this.nextTileId = maxId + 1;
+		this.score = s.score;
+		this.status = s.status;
+		this.keepPlaying = s.keepPlaying;
+		this.moveCount = s.moveCount;
+	}
+	pushHistory(s) {
+		this.history.push(s);
+		if (this.history.length > this.undoLimit) this.history.shift();
+	}
+	loadFromSave(save) {
+		this.grid = makeGrid(this.size);
+		let maxId = 0;
+		for (const raw of save.tiles) {
+			const t = {
+				id: raw.id,
+				value: raw.value,
+				row: raw.row,
+				col: raw.col,
+				isNew: false,
+				merged: false
+			};
+			if (t.row >= 0 && t.row < this.size && t.col >= 0 && t.col < this.size) {
+				const row = this.grid[t.row];
+				if (row) row[t.col] = t;
+			}
+			if (t.id > maxId) maxId = t.id;
+		}
+		this.score = save.score;
+		this.status = save.status === "won" ? "won" : save.status === "lost" ? "lost" : "playing";
+		this.keepPlaying = save.keepPlaying;
+		this.moveCount = save.moveCount;
+		this.nextTileId = Math.max(maxId + 1, save.nextTileId ?? maxId + 1);
+	}
+	commit() {
+		if (this.score > this.bestScore) {
+			this.bestScore = this.score;
+			writeBest(this.storage, this.bestKey, this.bestScore);
+		}
+		writeSave(this.storage, this.saveKey, {
+			version: 1,
+			size: this.size,
+			tiles: this.collectTiles().map((t) => ({ ...t })),
+			score: this.score,
+			status: this.status,
+			keepPlaying: this.keepPlaying,
+			moveCount: this.moveCount,
+			nextTileId: this.nextTileId
+		});
+		this.notify();
+	}
+	notify() {
+		if (this.notifying) return;
+		this.notifying = true;
+		try {
+			const snapshot = this.getState();
+			for (const fn of this.listeners) try {
+				fn(snapshot);
+			} catch (err) {
+				console.error("[game-2048] listener threw:", err);
+			}
+		} finally {
+			this.notifying = false;
+		}
+	}
+};
+// src/ai.ts
+/**
+* 2048 AI 求解器（expectimax + 蛇形权值评估）。
+*
+* 结构：
+* - Player 节点：4 个方向里挑 best（跳过非法方向）。
+* - Chance 节点：对每个空位分别按 0.9 / 0.1 概率注入 2 / 4，取期望值。
+* - 叶子：静态评估函数（蛇形权值 + 空位数奖励）。
+*
+* 4×4 棋盘 depth=3 单步耗时 <10ms，能稳定打出 5 位数分数；depth=4 更聪明但
+* 单次可能上百 ms，UI 层若要防卡帧可放到 Worker 里跑。
+*/
+var DIRS = [
+	"up",
+	"left",
+	"down",
+	"right"
+];
+/**
+* 4×4 蛇形权重（top-left 为蛇头 = 最大）：
+* ```
+* path (0,0)=15 (0,1)=14 (0,2)=13 (0,3)=12
+*      (1,0)= 8 (1,1)= 9 (1,2)=10 (1,3)=11
+*      (2,0)= 7 (2,1)= 6 (2,2)= 5 (2,3)= 4
+*      (3,0)= 0 (3,1)= 1 (3,2)= 2 (3,3)= 3
+* ```
+* 权重 = 2^path，越接近蛇头权越大。AI 由此把最大 tile 锁在左上角，
+* 形成「left/up 收拢、right/down 保持单调」的稳定策略。
+*/
+var SNAKE_WEIGHTS_4 = [
+	[
+		32768,
+		16384,
+		8192,
+		4096
+	],
+	[
+		256,
+		512,
+		1024,
+		2048
+	],
+	[
+		128,
+		64,
+		32,
+		16
+	],
+	[
+		1,
+		2,
+		4,
+		8
+	]
+];
+var NEW_TILE_PROBS = [[2, .9], [4, .1]];
+/** 通用蛇形权重（3/4/5/6 尺寸；沿 S 形折返，蛇头在 (0, 0)）。 */
+function buildWeights(size) {
+	if (size === 4) return SNAKE_WEIGHTS_4;
+	const cells = size * size;
+	const out = Array.from({ length: size }, () => Array(size).fill(0));
+	let path = cells - 1;
+	for (let r = 0; r < size; r++) {
+		const leftToRight = r % 2 === 0;
+		for (let i = 0; i < size; i++) {
+			const c = leftToRight ? i : size - 1 - i;
+			out[r][c] = path;
+			path--;
+		}
+	}
+	for (let r = 0; r < size; r++) for (let c = 0; c < size; c++) out[r][c] = (out[r][c] ?? 0) / cells;
+	return out;
+}
+/** 静态评估：值越靠近「蛇头」越大越好；空位多给额外奖励。 */
+function evaluate(grid, weights) {
+	let s = 0;
+	let empty = 0;
+	let max = 0;
+	for (let r = 0; r < grid.length; r++) {
+		const row = grid[r];
+		const w = weights[r];
+		if (!row || !w) continue;
+		for (let c = 0; c < row.length; c++) {
+			const v = row[c] ?? 0;
+			if (v === 0) empty++;
+			else {
+				s += Math.log2(v) * (w[c] ?? 0);
+				if (v > max) max = v;
+			}
+		}
+	}
+	return s * 1e3 + empty * 200 + Math.log2(max || 1);
+}
+/** 单步的期望值搜索（player 视角）。 */
+function expectimax(grid, depth, myTurn, weights) {
+	if (!canMove(grid)) return -Infinity;
+	if (depth === 0) return evaluate(grid, weights);
+	if (myTurn) {
+		let best = -Infinity;
+		for (const dir of DIRS) {
+			const { grid: next } = slideGrid(grid, dir);
+			if (gridsEqual(grid, next)) continue;
+			const v = expectimax(next, depth - 1, false, weights);
+			if (v > best) best = v;
+		}
+		return best === -Infinity ? evaluate(grid, weights) : best;
+	}
+	const empties = emptyCells(grid);
+	if (empties.length === 0) return evaluate(grid, weights);
+	let sum = 0;
+	const perCell = 1 / empties.length;
+	for (const [r, c] of empties) for (const [v, p] of NEW_TILE_PROBS) {
+		const g2 = cloneGrid(grid);
+		g2[r][c] = v;
+		sum += perCell * p * expectimax(g2, depth - 1, true, weights);
+	}
+	return sum;
+}
+/** 返回当前局面下最优方向；无解时 null。 */
+function bestMove(grid, opts = {}) {
+	const depth = opts.depth ?? 3;
+	if (!canMove(grid)) return null;
+	const weights = buildWeights(grid.length);
+	let best = null;
+	let bestScore = -Infinity;
+	for (const dir of DIRS) {
+		const { grid: next } = slideGrid(grid, dir);
+		if (gridsEqual(grid, next)) continue;
+		const v = expectimax(next, depth - 1, false, weights);
+		if (v > bestScore) {
+			bestScore = v;
+			best = dir;
+		}
+	}
+	return best;
+}
+/**
+* 让 AI 自动跑完整局，返回结束时的评估值。用于单测/基准。
+*
+* 起点若为完全空盘（如 `createEmptyGrid`），会先按真实开局规则补两枚 2/4，
+* 否则空盘 canMove=false 会立刻退出。
+*/
+function simulateUntilEnd(startGrid, opts = {}) {
+	const grid = cloneGrid(startGrid);
+	const depth = opts.depth ?? 3;
+	const defaultSpawn = (empties) => {
+		if (empties.length === 0) return null;
+		const cell = empties[Math.floor(Math.random() * empties.length)];
+		if (!cell) return null;
+		const [r, c] = cell;
+		return {
+			r,
+			c,
+			v: Math.random() < .9 ? 2 : 4
+		};
+	};
+	const spawnFn = opts.spawn ?? defaultSpawn;
+	const placeInitial = () => {
+		const empties = emptyCells(grid);
+		const pick = spawnFn(empties);
+		if (pick) grid[pick.r][pick.c] = pick.v;
+	};
+	if (emptyCells(grid).length === grid.length * grid.length) {
+		placeInitial();
+		placeInitial();
+	}
+	let steps = 0;
+	const cap = opts.maxSteps ?? 5e3;
+	while (steps < cap) {
+		const dir = bestMove(grid, { depth });
+		if (!dir) break;
+		const { grid: after } = slideGrid(grid, dir);
+		const empties = emptyCells(after);
+		if (empties.length > 0) {
+			const pick = spawnFn(empties);
+			if (pick) after[pick.r][pick.c] = pick.v;
+		}
+		grid.splice(0, grid.length, ...after);
+		steps++;
+		if (!canMove(grid)) break;
+	}
+	return {
+		grid,
+		steps
+	};
+}
+export { DEFAULT_BEST_KEY, DEFAULT_SAVE_KEY, Game2048, SAVE_VERSION, bestMove, canMove, clearSave, cloneGrid, createEmptyGrid, emptyCells, evaluate, gridsEqual, hasValue, isSerializedSave, loadBest, loadSave, maxValue, simulateUntilEnd, slideGrid, slideLineLeft, tryGetGlobalStorage, writeBest, writeSave };
+
 //# sourceMappingURL=index.js.map