koishi-plugin-play-go-chess 0.1.0

package/lib/go-engine.d.ts

@@ -0,0 +1,23 @@
+import { CellState, PlayerColor, Position, MoveResult } from './types';
+/**
+ * 获取包含 pos 的连通同色棋组 (BFS)
+ */
+export declare function getGroup(board: CellState[][], pos: Position): Position[];
+/**
+ * 获取棋组的所有气 (唯一空邻点)
+ */
+export declare function getLiberties(board: CellState[][], group: Position[]): Position[];
+/**
+ * 围棋落子核心逻辑
+ * 返回新棋盘状态（不修改原棋盘）、提子列表、是否有效、终局信息
+ */
+export declare function applyMove(board: CellState[][], pos: Position, color: PlayerColor, boardHistory?: string[]): MoveResult;
+/**
+ * 中国数子法计分
+ * 计算黑白双方在棋盘上的子+所围空的总数
+ */
+export declare function calculateScore(board: CellState[][], capturedByBlack: number, capturedByWhite: number, komi: number): {
+    black: number;
+    white: number;
+    winner: PlayerColor | 'draw';
+};

package/lib/go-engine.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGroup = getGroup;
+exports.getLiberties = getLiberties;
+exports.applyMove = applyMove;
+exports.calculateScore = calculateScore;
+const utils_1 = require("./utils");
+/**
+ * 获取包含 pos 的连通同色棋组 (BFS)
+ */
+function getGroup(board, pos) {
+    const size = board.length;
+    const color = board[pos.row][pos.col];
+    if (!color)
+        return [];
+    const group = [];
+    const visited = new Set();
+    const queue = [pos];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const key = `${current.row},${current.col}`;
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        group.push(current);
+        for (const [dr, dc] of utils_1.FOUR_DIRECTIONS) {
+            const nr = current.row + dr;
+            const nc = current.col + dc;
+            if (nr >= 0 && nr < size && nc >= 0 && nc < size && board[nr][nc] === color) {
+                const nKey = `${nr},${nc}`;
+                if (!visited.has(nKey)) {
+                    queue.push({ row: nr, col: nc });
+                }
+            }
+        }
+    }
+    return group;
+}
+/**
+ * 获取棋组的所有气 (唯一空邻点)
+ */
+function getLiberties(board, group) {
+    const size = board.length;
+    const liberties = [];
+    const seen = new Set();
+    for (const stone of group) {
+        for (const [dr, dc] of utils_1.FOUR_DIRECTIONS) {
+            const nr = stone.row + dr;
+            const nc = stone.col + dc;
+            if (nr >= 0 && nr < size && nc >= 0 && nc < size && board[nr][nc] === null) {
+                const key = `${nr},${nc}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    liberties.push({ row: nr, col: nc });
+                }
+            }
+        }
+    }
+    return liberties;
+}
+/**
+ * 围棋落子核心逻辑
+ * 返回新棋盘状态（不修改原棋盘）、提子列表、是否有效、终局信息
+ */
+function applyMove(board, pos, color, boardHistory) {
+    const size = board.length;
+    if (!(0, utils_1.isValidPosition)(pos, size)) {
+        return { valid: false, message: '坐标超出棋盘范围，请重新输入。' };
+    }
+    if (board[pos.row][pos.col] !== null) {
+        return { valid: false, message: '此交叉点已有棋子，请重新落子。' };
+    }
+    // 在副本上操作
+    const newBoard = (0, utils_1.cloneBoard)(board);
+    newBoard[pos.row][pos.col] = color;
+    const opponent = (0, utils_1.oppositeColor)(color);
+    const captured = [];
+    // 1. 检查并提走对方死棋
+    for (const [dr, dc] of utils_1.FOUR_DIRECTIONS) {
+        const nr = pos.row + dr;
+        const nc = pos.col + dc;
+        if (nr < 0 || nr >= size || nc < 0 || nc >= size)
+            continue;
+        if (newBoard[nr][nc] !== opponent)
+            continue;
+        const opponentGroup = getGroup(newBoard, { row: nr, col: nc });
+        const liberties = getLiberties(newBoard, opponentGroup);
+        if (liberties.length === 0) {
+            // 提子
+            for (const stone of opponentGroup) {
+                newBoard[stone.row][stone.col] = null;
+                captured.push(stone);
+            }
+        }
+    }
+    // 2. 检查己方是否有气 (禁着/自杀检测)
+    const ownGroup = getGroup(newBoard, pos);
+    const ownLiberties = getLiberties(newBoard, ownGroup);
+    if (ownLiberties.length === 0) {
+        return { valid: false, message: '禁入点：落子后己方无气（自杀禁着），请重新落子。' };
+    }
+    // 3. 劫争检测
+    if (boardHistory && isSuperko(boardHistory, newBoard)) {
+        return { valid: false, message: '劫争：此局面先前已出现过（全局同型禁止再现），请找劫材后重新落子。' };
+    }
+    return {
+        valid: true,
+        captured: captured.length > 0 ? captured : undefined,
+    };
+}
+/**
+ * 超级劫检测: 检查当前棋盘局面是否在历史中出现过
+ */
+function isSuperko(boardHistory, board) {
+    const serialized = (0, utils_1.serializeBoard)(board);
+    return boardHistory.includes(serialized);
+}
+/**
+ * 中国数子法计分
+ * 计算黑白双方在棋盘上的子+所围空的总数
+ */
+function calculateScore(board, capturedByBlack, capturedByWhite, komi) {
+    const size = board.length;
+    // 每个空点归属于接触的颜色 (只接触一种颜色则为该色的空; 接触两种则为中立)
+    const visited = new Set();
+    let blackTerritory = 0;
+    let whiteTerritory = 0;
+    let blackStones = 0;
+    let whiteStones = 0;
+    // 先数子
+    for (let r = 0; r < size; r++) {
+        for (let c = 0; c < size; c++) {
+            if (board[r][c] === 'black')
+                blackStones++;
+            else if (board[r][c] === 'white')
+                whiteStones++;
+        }
+    }
+    // 再数空 (对每个空区域进行泛洪)
+    for (let r = 0; r < size; r++) {
+        for (let c = 0; c < size; c++) {
+            if (board[r][c] !== null)
+                continue;
+            const key = `${r},${c}`;
+            if (visited.has(key))
+                continue;
+            // 泛洪此空区域
+            const region = floodFillEmpty(board, { row: r, col: c });
+            for (const p of region) {
+                visited.add(`${p.row},${p.col}`);
+            }
+            // 判断区域归属
+            let touchesBlack = false;
+            let touchesWhite = false;
+            for (const p of region) {
+                for (const [dr, dc] of utils_1.FOUR_DIRECTIONS) {
+                    const nr = p.row + dr;
+                    const nc = p.col + dc;
+                    if (nr < 0 || nr >= size || nc < 0 || nc >= size)
+                        continue;
+                    if (board[nr][nc] === 'black')
+                        touchesBlack = true;
+                    if (board[nr][nc] === 'white')
+                        touchesWhite = true;
+                }
+            }
+            if (touchesBlack && !touchesWhite) {
+                blackTerritory += region.length;
+            }
+            else if (touchesWhite && !touchesBlack) {
+                whiteTerritory += region.length;
+            }
+            // 双活区域不计入任何一方
+        }
+    }
+    // 中国规则: 子空皆地
+    const blackScore = blackStones + blackTerritory;
+    const whiteScore = whiteStones + whiteTerritory + komi;
+    let winner;
+    if (blackScore > whiteScore) {
+        winner = 'black';
+    }
+    else if (whiteScore > blackScore) {
+        winner = 'white';
+    }
+    else {
+        winner = 'draw';
+    }
+    return { black: blackScore, white: whiteScore, winner };
+}
+/**
+ * 泛洪填充一个空区域
+ */
+function floodFillEmpty(board, start) {
+    const size = board.length;
+    const region = [];
+    const visited = new Set();
+    const queue = [start];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const key = `${current.row},${current.col}`;
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        region.push(current);
+        for (const [dr, dc] of utils_1.FOUR_DIRECTIONS) {
+            const nr = current.row + dr;
+            const nc = current.col + dc;
+            if (nr >= 0 && nr < size && nc >= 0 && nc < size && board[nr][nc] === null) {
+                const nKey = `${nr},${nc}`;
+                if (!visited.has(nKey)) {
+                    queue.push({ row: nr, col: nc });
+                }
+            }
+        }
+    }
+    return region;
+}

package/lib/gomoku-engine.d.ts

@@ -0,0 +1,15 @@
+import { CellState, PlayerColor, Position, MoveResult } from './types';
+/**
+ * 检查指定颜色是否形成五连
+ * 从 lastPos 开始向四个方向扫描
+ */
+export declare function checkWin(board: CellState[][], color: PlayerColor, lastPos?: Position): boolean;
+/**
+ * 检测有禁手模式下黑方的禁手
+ * 返回禁手类型描述，或 null 表示不是禁手
+ */
+export declare function isForbiddenMove(board: CellState[][], pos: Position): string | null;
+/**
+ * 五子棋落子 (合并检查逻辑)
+ */
+export declare function applyGomokuMove(board: CellState[][], pos: Position, color: PlayerColor, mode: 'free' | 'restricted'): MoveResult;

package/lib/gomoku-engine.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWin = checkWin;
+exports.isForbiddenMove = isForbiddenMove;
+exports.applyGomokuMove = applyGomokuMove;
+const utils_1 = require("./utils");
+/**
+ * 检查指定颜色是否形成五连
+ * 从 lastPos 开始向四个方向扫描
+ */
+function checkWin(board, color, lastPos) {
+    const size = board.length;
+    const directions = [
+        [0, 1], // 水平
+        [1, 0], // 垂直
+        [1, 1], // 对角线 ↘
+        [1, -1], // 对角线 ↙
+    ];
+    const checkPos = lastPos || findLastMove(board, color);
+    if (!checkPos) {
+        // 全盘扫描 (仅在无 lastPos 时，用于初始化后)
+        for (let r = 0; r < size; r++) {
+            for (let c = 0; c < size; c++) {
+                if (board[r][c] !== color)
+                    continue;
+                for (const [dr, dc] of directions) {
+                    if (countConsecutive(board, { row: r, col: c }, dr, dc, color) >= 5) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    // 从最后落子位置检查
+    for (const [dr, dc] of directions) {
+        const count = countConsecutive(board, checkPos, dr, dc, color);
+        if (count >= 5)
+            return true;
+    }
+    return false;
+}
+/**
+ * 查找棋盘上最后一个同色棋子(用于无 lastPos 时的扫描起点)
+ */
+function findLastMove(board, color) {
+    // 简化: 返回第一个找到的该色棋子
+    for (let r = 0; r < board.length; r++) {
+        for (let c = 0; c < board.length; c++) {
+            if (board[r][c] === color)
+                return { row: r, col: c };
+        }
+    }
+    return null;
+}
+/**
+ * 从 pos 开始沿 (dr, dc) 方向计数连续同色棋子 (包括 pos 本身)
+ * 向正反两个方向计数
+ */
+function countConsecutive(board, pos, dr, dc, color) {
+    const size = board.length;
+    let count = 1; // 包括 pos 本身
+    // 正方向
+    let r = pos.row + dr;
+    let c = pos.col + dc;
+    while (r >= 0 && r < size && c >= 0 && c < size && board[r][c] === color) {
+        count++;
+        r += dr;
+        c += dc;
+    }
+    // 反方向
+    r = pos.row - dr;
+    c = pos.col - dc;
+    while (r >= 0 && r < size && c >= 0 && c < size && board[r][c] === color) {
+        count++;
+        r -= dr;
+        c -= dc;
+    }
+    return count;
+}
+/**
+ * 检测有禁手模式下黑方的禁手
+ * 返回禁手类型描述，或 null 表示不是禁手
+ */
+function isForbiddenMove(board, pos) {
+    const size = board.length;
+    // 在 pos 处模拟放置黑子
+    const simBoard = (0, utils_1.cloneBoard)(board);
+    simBoard[pos.row][pos.col] = 'black';
+    // 1. 检查长连 (超过 5 子)
+    if (hasOverline(simBoard, pos)) {
+        return '长连禁手：落子后形成六子或更长连线，请重新落子。';
+    }
+    // 2. 检查五连 — 五连不是禁手 (允许获胜)
+    if (checkWin(simBoard, 'black', pos)) {
+        return null;
+    }
+    // 3. 检查双四
+    const fourCount = countFours(simBoard, pos);
+    if (fourCount >= 2) {
+        return '双四禁手：一子同时形成两个四，请重新落子。';
+    }
+    // 4. 检查双三
+    const threeCount = countOpenThrees(simBoard, pos);
+    if (threeCount >= 2) {
+        return '双三禁手：一子同时形成两个活三，请重新落子。';
+    }
+    return null;
+}
+/**
+ * 检查从 pos 开始是否有长连 (超过 5)
+ */
+function hasOverline(board, pos) {
+    const directions = [[0, 1], [1, 0], [1, 1], [1, -1]];
+    for (const [dr, dc] of directions) {
+        if (countConsecutive(board, pos, dr, dc, 'black') > 5) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 统计 pos 处的冲四/活四数量
+ * 四: 4 子连续且至少一端开放
+ */
+function countFours(board, pos) {
+    const directions = [[0, 1], [1, 0], [1, 1], [1, -1]];
+    let count = 0;
+    for (const [dr, dc] of directions) {
+        if (isFour(board, pos, dr, dc)) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * 检查在 (dr, dc) 方向上是否形成四
+ */
+function isFour(board, pos, dr, dc) {
+    const size = board.length;
+    const consecutive = countConsecutive(board, pos, dr, dc, 'black');
+    if (consecutive !== 4)
+        return false;
+    // 检查两端: 至少一端为空
+    const forwardR = pos.row + dr * consecutive; // 实际上应该是 +dr * forwardCount
+    const forwardC = pos.col + dc * consecutive;
+    // 重新计算: 找到整个连续段的两端
+    let startR = pos.row;
+    let startC = pos.col;
+    while (startR - dr >= 0 && startR - dr < size && startC - dc >= 0 && startC - dc < size && board[startR - dr][startC - dc] === 'black') {
+        startR -= dr;
+        startC -= dc;
+    }
+    let endR = pos.row;
+    let endC = pos.col;
+    while (endR + dr >= 0 && endR + dr < size && endC + dc >= 0 && endC + dc < size && board[endR + dr][endC + dc] === 'black') {
+        endR += dr;
+        endC += dc;
+    }
+    // 检查两端是否为空
+    const beforeEmpty = (0, utils_1.isValidPosition)({ row: startR - dr, col: startC - dc }, size)
+        && board[startR - dr][startC - dc] === null;
+    const afterEmpty = (0, utils_1.isValidPosition)({ row: endR + dr, col: endC + dc }, size)
+        && board[endR + dr][endC + dc] === null;
+    return beforeEmpty || afterEmpty;
+}
+/**
+ * 统计 pos 处的活三数量
+ * 活三: 3 子连续，两端都开放，且延伸后能形成活四
+ */
+function countOpenThrees(board, pos) {
+    const directions = [[0, 1], [1, 0], [1, 1], [1, -1]];
+    let count = 0;
+    for (const [dr, dc] of directions) {
+        if (isOpenThree(board, pos, dr, dc)) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * 检查在 (dr, dc) 方向上是否形成活三
+ */
+function isOpenThree(board, pos, dr, dc) {
+    const size = board.length;
+    // 找到包含 pos 的连续黑子段
+    let startR = pos.row;
+    let startC = pos.col;
+    while (startR - dr >= 0 && startR - dr < size && startC - dc >= 0 && startC - dc < size && board[startR - dr][startC - dc] === 'black') {
+        startR -= dr;
+        startC -= dc;
+    }
+    let endR = pos.row;
+    let endC = pos.col;
+    while (endR + dr >= 0 && endR + dr < size && endC + dc >= 0 && endC + dc < size && board[endR + dr][endC + dc] === 'black') {
+        endR += dr;
+        endC += dc;
+    }
+    const seqLen = Math.max(Math.abs(endR - startR), Math.abs(endC - startC)) + 1;
+    if (seqLen !== 3)
+        return false;
+    // 两端必须都为空
+    const beforeR = startR - dr;
+    const beforeC = startC - dc;
+    const afterR = endR + dr;
+    const afterC = endC + dc;
+    if (!(0, utils_1.isValidPosition)({ row: beforeR, col: beforeC }, size) || board[beforeR][beforeC] !== null)
+        return false;
+    if (!(0, utils_1.isValidPosition)({ row: afterR, col: afterC }, size) || board[afterR][afterC] !== null)
+        return false;
+    // 进一步检查: 两端延伸一格后不是对方棋子 (确保是真正的活三)
+    const beyondBeforeR = beforeR - dr;
+    const beyondBeforeC = beforeC - dc;
+    const beyondAfterR = afterR + dr;
+    const beyondAfterC = afterC + dc;
+    const beforeBlocked = !(0, utils_1.isValidPosition)({ row: beyondBeforeR, col: beyondBeforeC }, size)
+        || board[beyondBeforeR][beyondBeforeC] === 'white';
+    const afterBlocked = !(0, utils_1.isValidPosition)({ row: beyondAfterR, col: beyondAfterC }, size)
+        || board[beyondAfterR][beyondAfterC] === 'white';
+    // 活三要求两端都不被堵死
+    return !beforeBlocked || !afterBlocked;
+}
+/**
+ * 五子棋落子 (合并检查逻辑)
+ */
+function applyGomokuMove(board, pos, color, mode) {
+    const size = board.length;
+    if (!(0, utils_1.isValidPosition)(pos, size)) {
+        return { valid: false, message: '坐标超出棋盘范围，请重新输入。' };
+    }
+    if (board[pos.row][pos.col] !== null) {
+        return { valid: false, message: '此交叉点已有棋子，请重新落子。' };
+    }
+    // 有禁手模式：检查黑方禁手
+    if (mode === 'restricted' && color === 'black') {
+        const forbidden = isForbiddenMove(board, pos);
+        if (forbidden) {
+            return { valid: false, message: forbidden };
+        }
+    }
+    // 应用落子
+    const newBoard = (0, utils_1.cloneBoard)(board);
+    newBoard[pos.row][pos.col] = color;
+    // 检查是否获胜
+    const isWin = checkWin(newBoard, color, pos);
+    return {
+        valid: true,
+        gameOver: isWin,
+        winner: isWin ? color : undefined,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,16 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "play-go-chess";
+export declare const inject: readonly ["database", "canvas"];
+export interface Config {
+    commandStart: string;
+    commandPlace: string;
+    commandPass: string;
+    commandUndo: string;
+    commandResign: string;
+    commandEnd: string;
+    commandView: string;
+    commandStats: string;
+    goKomi: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+exports.name = 'play-go-chess';
+exports.inject = ['database', 'canvas'];
+exports.Config = koishi_1.Schema.object({
+    commandStart: koishi_1.Schema.string().default('下棋').description('开始/创建棋局'),
+    commandPlace: koishi_1.Schema.string().default('落子').description('落子（非开局者落子时自动加入对局）'),
+    commandPass: koishi_1.Schema.string().default('停一手').description('停着（围棋/黑白棋，也可用于加入对局）'),
+    commandUndo: koishi_1.Schema.string().default('悔棋').description('悔棋（回退一步，可多次使用）'),
+    commandResign: koishi_1.Schema.string().default('认输').description('认输'),
+    commandEnd: koishi_1.Schema.string().default('结束对局').description('主动结束对局（中止当前频道对局）'),
+    commandView: koishi_1.Schema.string().default('查看').description('查看当前棋盘'),
+    commandStats: koishi_1.Schema.string().default('我的战绩').description('查看个人三棋战绩'),
+    goKomi: koishi_1.Schema.number().default(7.5).min(0).max(20).step(0.5).description('围棋贴目'),
+});
+function apply(ctx, config) {
+    // 数据库模型：玩家战绩
+    ctx.model.extend('chess_player_stats', {
+        id: 'unsigned',
+        userId: 'string',
+        platform: 'string',
+        goGames: 'unsigned',
+        goWins: 'unsigned',
+        goLosses: 'unsigned',
+        goDraws: 'unsigned',
+        gomokuGames: 'unsigned',
+        gomokuWins: 'unsigned',
+        gomokuLosses: 'unsigned',
+        gomokuDraws: 'unsigned',
+        othelloGames: 'unsigned',
+        othelloWins: 'unsigned',
+        othelloLosses: 'unsigned',
+        othelloDraws: 'unsigned',
+    }, { autoInc: true });
+    // 延迟导入，避免循环依赖
+    let manager;
+    ctx.on('ready', async () => {
+        const { GameManager } = await Promise.resolve().then(() => __importStar(require('./manager')));
+        manager = new GameManager(ctx, config);
+    });
+    ctx.command(`${config.commandStart} <game> [...options]`)
+        .action(async ({ session }, game, ...options) => {
+        if (!session)
+            return '无法获取会话信息。';
+        if (game === '帮助' || game === 'help') {
+            return manager.showHelp();
+        }
+        return manager.startGame(session, game, options.join(' '));
+    });
+    ctx.command(`${config.commandPlace} <position>`)
+        .action(async ({ session }, position) => {
+        if (!session)
+            return '无法获取会话信息。';
+        if (!position)
+            return `请输入落子坐标，例如：${config.commandPlace} A1`;
+        return manager.placeStone(session, position);
+    });
+    ctx.command(config.commandPass)
+        .action(async ({ session }) => {
+        if (!session)
+            return '无法获取会话信息。';
+        return manager.pass(session);
+    });
+    ctx.command(config.commandUndo)
+        .action(async ({ session }) => {
+        if (!session)
+            return '无法获取会话信息。';
+        return manager.undo(session);
+    });
+    ctx.command(config.commandResign)
+        .action(async ({ session }) => {
+        if (!session)
+            return '无法获取会话信息。';
+        return manager.resign(session);
+    });
+    ctx.command(config.commandEnd)
+        .action(async ({ session }) => {
+        if (!session)
+            return '无法获取会话信息。';
+        return manager.endGame(session);
+    });
+    ctx.command(config.commandView)
+        .action(async ({ session }) => {
+        if (!session)
+            return '无法获取会话信息。';
+        return manager.viewBoard(session);
+    });
+    ctx.command(config.commandStats)
+        .action(async ({ session }) => {
+        if (!session)
+            return '无法获取会话信息。';
+        return manager.showStats(session);
+    });
+    // ── 各棋类帮助指令 ──────────────────────────────────────────────
+    const gameHelpCommands = [
+        { name: '围棋', type: 'go', desc: '围棋帮助' },
+        { name: '五子棋', type: 'gomoku', desc: '五子棋帮助' },
+        { name: '黑白棋', type: 'othello', desc: '黑白棋帮助' },
+    ];
+    for (const { name, type } of gameHelpCommands) {
+        ctx.command(`${name} [...args]`)
+            .action(async ({ session }, ...args) => {
+            if (!session)
+                return '无法获取会话信息。';
+            const arg = args.join(' ').trim();
+            if (arg === '帮助' || arg === 'help' || !arg) {
+                return manager.showGameHelp(type);
+            }
+            return `未知参数「${arg}」。输入「${name} 帮助」查看详细规则，或使用「${config.commandStart} ${name}」创建对局。`;
+        });
+    }
+}