设为首页收藏本站
切换到宽版

 找回密码
 注册
搜索
无忧启动论坛»论坛 › ::启动制作:: › 综合讨论区 › 求热心网友,转运中国象棋专业版2.0 - html原码 ...
系统gho:最纯净好用系统下载站投放广告、加入VIP会员，请联系 微信:wuyouceo
12下一页
返回列表 发新帖
查看: 475|回复: 37

[求助] 求热心网友,转运中国象棋专业版2.0 - html原码

[复制链接]
发表于 13 小时前 | 显示全部楼层 |阅读模式
本帖最后由 crtrccrtt 于 2026-3-19 11:13 编辑

求热心网友,转运中国象棋专业版2.0 - html原码

https://www.52pojie.cn/thread-2097870-1-1.html


五子棋专业版2.4 - 网页版



经使用，这个象棋，水平太差，不推荐使用。
回复

使用道具 举报

it323
发表于 13 小时前 | 显示全部楼层
期待热心网友...........
回复

使用道具 举报

2013WCL
发表于 12 小时前 | 显示全部楼层
我是热心网友

中国象棋专业版2.0.rar

6.85 KB, 下载次数: 66, 下载积分: 无忧币 -2

点评

fh123456
AI执红，第一步居然是帅五进一  发表于 9 小时前
it323
非常热  详情 回复 发表于 12 小时前
yyz2191958
好人  发表于 12 小时前
菲菲18866
很热  发表于 12 小时前

评分

参与人数 3无忧币 +15 收起 理由
cuicongyuan + 5 热
it323 + 5 赞一个!
yyz2191958 + 5

查看全部评分

回复

使用道具 举报

1e3e
发表于 12 小时前 | 显示全部楼层
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>中国象棋专业版2.0</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            user-select: none;
        }
        body {
            background: #1a1a1a;
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            font-family: '楷体', 'KaiTi', '华文楷体', serif;
        }
        .game-container {
            background: transparent;
            padding: 20px;
            border-radius: 0;
            box-shadow: none;
            border: none;
            display: flex;
            gap: 40px;
            align-items: center;
        }
        /* 强制canvas显示尺寸与像素尺寸一致，防止浏览器缩放导致模糊 */
        canvas {
            display: block;
            width: 560px;
            height: 630px;
            border-radius: 18px;
            box-shadow: 0 10px 20px rgba(0,0,0,0.3);
            background: #f0d9b5;
            cursor: pointer;
        }
        .right-panel {
            display: flex;
            flex-direction: column;
            gap: 15px;
            align-items: center;
            justify-content: center;
            min-width: 160px;
        }
        .turn-indicator {
            background: #5e3e1e;
            color: #f9eac3;
            padding: 8px 12px;
            border-radius: 50px;
            font-size: 22px;
            letter-spacing: 2px;
            box-shadow: inset 0 -3px 0 #2f1f0e, 0 6px 10px black;
            border-bottom: 2px solid #b5914c;
            width: 100%;
            text-align: center;
            margin-bottom: 5px;
        }
        .mode-selector, .difficulty-selector {
            background: #c29e5e;
            border-radius: 40px;
            padding: 8px 12px;
            font-size: 20px;
            font-weight: bold;
            color: #2b1a0a;
            border: 2px solid #efd39e;
            box-shadow: inset 0 -2px 0 #6f4f2e, 0 6px 8px black;
            cursor: pointer;
            outline: none;
            width: 100%;
            text-align: center;
        }
        .action-btn {
            background: #c29e5e;
            border: none;
            font-size: 22px;
            font-family: '楷体', serif;
            font-weight: bold;
            padding: 8px 0;
            border-radius: 40px;
            color: #2b1a0a;
            box-shadow: 0 8px 0 #6f4f2e, 0 10px 15px black;
            cursor: pointer;
            transition: 0.08s linear;
            border: 1px solid #efd39e;
            letter-spacing: 2px;
            width: 100%;
        }
        .action-btn:active {
            transform: translateY(7px);
            box-shadow: 0 2px 0 #5a3f22, 0 8px 12px black;
        }
    </style>
</head>
<body>
    <div class="game-container">
        <canvas id="chessCanvas" width="560" height="630"></canvas>
        <div class="right-panel">
            <div class="turn-indicator" id="turnText">红方走棋</div>
            <select id="modeSelect" class="mode-selector">
                <option value="human" selected>双人对战</option>
                <option value="ai-black">&#129302;AI执黑</option>
                <option value="ai-red">&#129302;AI执红</option>
            </select>
            <select id="difficultySelect" class="difficulty-selector">
                <option value="1">&#129302;初级1层</option>
                <option value="2" selected>&#129302;中级2层</option>
                <option value="3">&#129302;高级3层</option>
            </select>
            <button class="action-btn" id="undoBtn">悔棋</button>
            <button class="action-btn restart-btn" id="restartBtn">新局</button>
        </div>
    </div>

    <script>
        (function() {
            // ---------- 棋盘配置 ----------
            const canvas = document.getElementById('chessCanvas');
            const ctx = canvas.getContext('2d');
            const turnText = document.getElementById('turnText');
            const modeSelect = document.getElementById('modeSelect');
            const difficultySelect = document.getElementById('difficultySelect');
            const undoBtn = document.getElementById('undoBtn');
            const restartBtn = document.getElementById('restartBtn');

            const ROWS = 10;
            const COLS = 9;
            const GRID_SIZE = 56;
            const OFFSET_X = 56;
            const OFFSET_Y = 63;

            // ---------- 全局状态 ----------
            let board = [];
            let currentPlayer = 'r';
            let selectedPiece = null;
            let gameOver = false;
            let winner = null;               
            let history = [];

            // AI 相关
            let gameMode = 'human';
            let aiDifficulty = 2;
            let isAIPlaying = false;

            let killerMoves = [];
            const MAX_DEPTH = 10;
            function initKillers() {
                killerMoves = [];
                for (let d = 0; d <= MAX_DEPTH; d++) killerMoves[d] = [null, null];
            }
            initKillers();

            const pieceValue = {
                'k': 10000, 'a': 200, 'b': 200, 'n': 500, 'r': 1000, 'c': 800, 'p': 100
            };

            function initBoard() {
                board = Array(ROWS).fill().map(() => Array(COLS).fill(null));

                board[0][0] = 'br'; board[0][1] = 'bn'; board[0][2] = 'bb'; board[0][3] = 'ba'; board[0][4] = 'bk';
                board[0][5] = 'ba'; board[0][6] = 'bb'; board[0][7] = 'bn'; board[0][8] = 'br';
                board[2][1] = 'bc'; board[2][7] = 'bc';
                board[3][0] = 'bp'; board[3][2] = 'bp'; board[3][4] = 'bp'; board[3][6] = 'bp'; board[3][8] = 'bp';

                board[9][0] = 'rr'; board[9][1] = 'rn'; board[9][2] = 'rb'; board[9][3] = 'ra'; board[9][4] = 'rk';
                board[9][5] = 'ra'; board[9][6] = 'rb'; board[9][7] = 'rn'; board[9][8] = 'rr';
                board[7][1] = 'rc'; board[7][7] = 'rc';
                board[6][0] = 'rp'; board[6][2] = 'rp'; board[6][4] = 'rp'; board[6][6] = 'rp'; board[6][8] = 'rp';

                currentPlayer = 'r';
                selectedPiece = null;
                gameOver = false;
                winner = null;
                history = [];
                turnText.innerText = '红方走棋';
                initKillers();
            }

            // ---------- 绘制函数 (锐化处理) ----------
            function drawBoard() {
                ctx.clearRect(0, 0, canvas.width, canvas.height);
                drawGrid();
                drawPieces();
                if (selectedPiece) {
                    const { row, col } = selectedPiece;
                    // 选中高亮：坐标对齐到半像素，阴影调小
                    ctx.save();
                    ctx.strokeStyle = '#f5e56b';
                    ctx.lineWidth = 3;
                    ctx.shadowBlur = 6;          // 减小阴影模糊
                    ctx.shadowColor = 'gold';
                    ctx.beginPath();
                    // 使用半像素坐标使圆弧边缘更清晰
                    ctx.arc(OFFSET_X + col * GRID_SIZE + 0.5, OFFSET_Y + row * GRID_SIZE + 0.5, 24, 0, 2 * Math.PI);
                    ctx.stroke();
                    ctx.restore();
                }
            }

            function drawGrid() {
                ctx.save();
                ctx.strokeStyle = '#6b4f32';
                ctx.lineWidth = 1;               // 线宽设为1，配合半像素坐标获得锐利直线

                // 绘制横线 (坐标+0.5使线条精确覆盖像素)
                for (let i = 0; i < ROWS; i++) {
                    ctx.beginPath();
                    ctx.moveTo(OFFSET_X + 0.5, OFFSET_Y + i * GRID_SIZE + 0.5);
                    ctx.lineTo(OFFSET_X + (COLS - 1) * GRID_SIZE + 0.5, OFFSET_Y + i * GRID_SIZE + 0.5);
                    ctx.stroke();
                }
                // 绘制竖线
                for (let i = 0; i < COLS; i++) {
                    ctx.beginPath();
                    ctx.moveTo(OFFSET_X + i * GRID_SIZE + 0.5, OFFSET_Y + 0.5);
                    ctx.lineTo(OFFSET_X + i * GRID_SIZE + 0.5, OFFSET_Y + (ROWS - 1) * GRID_SIZE + 0.5);
                    ctx.stroke();
                }

                // 绘制楚河汉界 (半透明背景文字，稍微下移一点避开中线，保留原风格)
                ctx.font = '35px "楷体", "KaiTi"';
                ctx.fillStyle = '#4e2f15';
                ctx.globalAlpha = 0.3;
                const text = '楚 河   　    　汉 界';
                const textWidth = ctx.measureText(text).width;
                const boardLeft = OFFSET_X;
                const boardRight = OFFSET_X + (COLS - 1) * GRID_SIZE;
                const centerX = (boardLeft + boardRight) / 2;
                const textX = centerX - textWidth / 2;
                // 保持文字整数坐标防止模糊 (半透明背景无需锐利)
                ctx.fillText(text, textX, OFFSET_Y + 5 * GRID_SIZE - 13);
                ctx.globalAlpha = 1;

                // 九宫对角线 (同样用半像素坐标)
                ctx.beginPath();
                ctx.moveTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 0.5);
                ctx.lineTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 2 * GRID_SIZE + 0.5);
                ctx.stroke();
                ctx.beginPath();
                ctx.moveTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 0.5);
                ctx.lineTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 2 * GRID_SIZE + 0.5);
                ctx.stroke();

                ctx.beginPath();
                ctx.moveTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 7 * GRID_SIZE + 0.5);
                ctx.lineTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 9 * GRID_SIZE + 0.5);
                ctx.stroke();
                ctx.beginPath();
                ctx.moveTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 7 * GRID_SIZE + 0.5);
                ctx.lineTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 9 * GRID_SIZE + 0.5);
                ctx.stroke();

                // 绘制炮/兵/卒标记点 (使用半像素坐标，使圆点清晰)
                ctx.fillStyle = '#6b4f32';
                ctx.shadowBlur = 0; // 标记点不要阴影
                for (let r of [2, 7]) {
                    for (let c of [1, 7]) {
                        ctx.beginPath();
                        ctx.arc(OFFSET_X + c * GRID_SIZE + 0.5, OFFSET_Y + r * GRID_SIZE + 0.5, 5, 0, 2 * Math.PI);
                        ctx.fill();
                    }
                }
                for (let r of [3, 6]) {
                    for (let c of [0, 2, 4, 6, 8]) {
                        ctx.beginPath();
                        ctx.arc(OFFSET_X + c * GRID_SIZE + 0.5, OFFSET_Y + r * GRID_SIZE + 0.5, 4, 0, 2 * Math.PI);
                        ctx.fill();
                    }
                }
                ctx.restore();
            }

            function drawPieces() {
                for (let r = 0; r < ROWS; r++) {
                    for (let c = 0; c < COLS; c++) {
                        const piece = board[r][c];
                        if (!piece) continue;
                        // 圆心坐标对齐半像素，使棋子边缘清晰
                        const x = OFFSET_X + c * GRID_SIZE + 0.5;
                        const y = OFFSET_Y + r * GRID_SIZE + 0.5;

                        ctx.save();
                        // 棋子阴影减弱
                        ctx.shadowColor = '#333';
                        ctx.shadowBlur = 4;        // 原为8，减半减少模糊
                        ctx.shadowOffsetY = 2;      // 原为3
                        ctx.beginPath();
                        ctx.arc(x, y, 24, 0, 2 * Math.PI);
                        ctx.fillStyle = piece[0] === 'r' ? '#c33' : '#222';
                        ctx.fill();
                        ctx.shadowBlur = 2;          // 描边阴影稍弱
                        ctx.strokeStyle = '#f1d28c';
                        ctx.lineWidth = 2;
                        ctx.stroke();

                        // 绘制文字前清除阴影，保证文字清晰
                        ctx.shadowBlur = 0;
                        ctx.shadowOffsetY = 0;
                        ctx.font = '35px "楷体", "KaiTi", "华文楷体", serif';
                        ctx.fillStyle = piece[0] === 'r' ? '#FFD966' : '#ddd';
                        ctx.textAlign = 'center';
                        ctx.textBaseline = 'middle';
                        // 微调偏移量，配合半像素圆心，文字仍保留轻微偏移以居中
                        ctx.fillText(pieceToChinese(piece), x - 1, y + 5);
                        ctx.restore();
                    }
                }
            }

            function pieceToChinese(p) {
                const map = {
                    'r': { 'k': '帅', 'a': '仕', 'b': '相', 'n': '马', 'r': '车', 'c': '炮', 'p': '兵' },
                    'b': { 'k': '将', 'a': '士', 'b': '象', 'n': '马', 'r': '车', 'c': '炮', 'p': '卒' }
                };
                return map[p[0]][p[1]] || '?';
            }

            // ---------- 规则核心函数 (保持不变，保证AI逻辑正确) ----------
            function getPieceRawMoves(boardState, row, col, piece) {
                const color = piece[0];
                const type = piece[1];
                const moves = [];

                if (type === 'k') {
                    const palaceRows = (color === 'r') ? [7,8,9] : [0,1,2];
                    const palaceCols = [3,4,5];
                    const dirs = [[-1,0],[1,0],[0,-1],[0,1]];
                    for (let [dx,dy] of dirs) {
                        const nr = row+dx, nc = col+dy;
                        if (palaceRows.includes(nr) && palaceCols.includes(nc)) {
                            const target = boardState[nr]?.[nc];
                            if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
                        }
                    }
                }
                else if (type === 'a') {
                    const palaceRows = (color === 'r') ? [7,8,9] : [0,1,2];
                    const palaceCols = [3,4,5];
                    const dirs = [[-1,-1],[-1,1],[1,-1],[1,1]];
                    for (let [dx,dy] of dirs) {
                        const nr = row+dx, nc = col+dy;
                        if (palaceRows.includes(nr) && palaceCols.includes(nc)) {
                            const target = boardState[nr]?.[nc];
                            if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
                        }
                    }
                }
                else if (type === 'b') {
                    const dirs = [[-2,-2],[-2,2],[2,-2],[2,2]];
                    for (let [dx,dy] of dirs) {
                        const nr = row+dx, nc = col+dy;
                        if (nr<0 || nr>=ROWS || nc<0 || nc>=COLS) continue;
                        if (color === 'r' && nr < 5) continue;
                        if (color === 'b' && nr > 4) continue;
                        const eyeRow = row + dx/2, eyeCol = col + dy/2;
                        if (boardState[eyeRow][eyeCol] !== null) continue;
                        const target = boardState[nr][nc];
                        if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
                    }
                }
                else if (type === 'n') {
                    const jumps = [[-2,-1],[-2,1],[-1,-2],[-1,2],[1,-2],[1,2],[2,-1],[2,1]];
                    for (let [dx,dy] of jumps) {
                        const nr = row+dx, nc = col+dy;
                        if (nr<0 || nr>=ROWS || nc<0 || nc>=COLS) continue;
                        let blockRow = row, blockCol = col;
                        if (Math.abs(dx) === 2) { blockRow = row + (dx>0?1:-1); blockCol = col; }
                        else { blockRow = row; blockCol = col + (dy>0?1:-1); }
                        if (boardState[blockRow][blockCol] !== null) continue;
                        const target = boardState[nr][nc];
                        if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
                    }
                }
                else if (type === 'r') {
                    const dirs = [[-1,0],[1,0],[0,-1],[0,1]];
                    for (let [dx,dy] of dirs) {
                        let nr = row+dx, nc = col+dy;
                        while (nr>=0 && nr<ROWS && nc>=0 && nc<COLS) {
                            const target = boardState[nr][nc];
                            if (!target) moves.push({toX:nr, toY:nc});
                            else {
                                if (target[0] !== color) moves.push({toX:nr, toY:nc});
                                break;
                            }
                            nr += dx; nc += dy;
                        }
                    }
                }
                else if (type === 'c') {
                    const dirs = [[-1,0],[1,0],[0,-1],[0,1]];
                    for (let [dx,dy] of dirs) {
                        let nr = row+dx, nc = col+dy;
                        let foundObstacle = false;
                        while (nr>=0 && nr<ROWS && nc>=0 && nc<COLS) {
                            const target = boardState[nr][nc];
                            if (!foundObstacle) {
                                if (!target) moves.push({toX:nr, toY:nc});
                                else foundObstacle = true;
                            } else {
                                if (target && target[0] !== color) {
                                    moves.push({toX:nr, toY:nc});
                                    break;
                                } else if (target) break;
                            }
                            nr += dx; nc += dy;
                        }
                    }
                }
                else if (type === 'p') {
                    const forward = (color === 'r') ? -1 : 1;
                    let nr = row + forward, nc = col;
                    if (nr>=0 && nr<ROWS) {
                        const target = boardState[nr][nc];
                        if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
                    }
                    const crossed = (color === 'r') ? row <= 4 : row >= 5;
                    if (crossed) {
                        for (let dc of [-1,1]) {
                            nr = row; nc = col + dc;
                            if (nc>=0 && nc<COLS) {
                                const target = boardState[nr][nc];
                                if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
                            }
                        }
                    }
                }
                return moves;
            }

            function applyMove(boardState, fromX, fromY, toX, toY) {
                const newBoard = boardState.map(row => row.map(cell => cell));
                const piece = newBoard[fromX][fromY];
                newBoard[toX][toY] = piece;
                newBoard[fromX][fromY] = null;
                return newBoard;
            }

            function isKingInCheck(boardState, color) {
                let kingPos = null;
                for (let r=0; r<ROWS; r++) {
                    for (let c=0; c<COLS; c++) {
                        const p = boardState[r][c];
                        if (p && p[0]===color && p[1]==='k') kingPos = [r,c];
                    }
                }
                if (!kingPos) return false;
                const opponent = color==='r' ? 'b' : 'r';
                for (let r=0; r<ROWS; r++) {
                    for (let c=0; c<COLS; c++) {
                        const p = boardState[r][c];
                        if (p && p[0]===opponent) {
                            const rawMoves = getPieceRawMoves(boardState, r, c, p);
                            for (let m of rawMoves) {
                                if (m.toX === kingPos[0] && m.toY === kingPos[1]) return true;
                            }
                        }
                    }
                }
                return false;
            }

            function hasGeneralsFacing(boardState) {
                let redKing = null, blackKing = null;
                for (let r=0; r<ROWS; r++) {
                    for (let c=0; c<COLS; c++) {
                        const p = boardState[r][c];
                        if (p && p[1]==='k') {
                            if (p[0]==='r') redKing = [r,c];
                            else blackKing = [r,c];
                        }
                    }
                }
                if (!redKing || !blackKing) return false;
                if (redKing[1] !== blackKing[1]) return false;
                const col = redKing[1];
                const minRow = Math.min(redKing[0], blackKing[0]);
                const maxRow = Math.max(redKing[0], blackKing[0]);
                for (let r = minRow+1; r < maxRow; r++) {
                    if (boardState[r][col] !== null) return false;
                }
                return true;
            }

            function getAllValidMoves(boardState, color) {
                const moves = [];
                for (let r=0; r<ROWS; r++) {
                    for (let c=0; c<COLS; c++) {
                        const piece = boardState[r][c];
                        if (!piece || piece[0] !== color) continue;
                        const raw = getPieceRawMoves(boardState, r, c, piece);
                        for (let m of raw) {
                            const newBoard = applyMove(boardState, r, c, m.toX, m.toY);
                            if (isKingInCheck(newBoard, color)) continue;
                            if (hasGeneralsFacing(newBoard)) continue;
                            const pieceVal = pieceValue[piece[1]] || 0;
                            const target = boardState[m.toX][m.toY];
                            const targetVal = target ? (pieceValue[target[1]] || 0) : 0;
                            moves.push({
                                fromX: r, fromY: c,
                                toX: m.toX, toY: m.toY,
                                pieceValue: pieceVal, targetValue: targetVal
                            });
                        }
                    }
                }
                return moves;
            }

            function evaluateBoard(boardState, perspective) {
                let score = 0;
                for (let r=0; r<ROWS; r++) {
                    for (let c=0; c<COLS; c++) {
                        const p = boardState[r][c];
                        if (!p) continue;
                        const val = pieceValue[p[1]] || 0;
                        if (p[0] === perspective) score += val;
                        else score -= val;
                    }
                }
                return score;
            }

            function alphaBeta(boardState, depth, alpha, beta, maximizing, aiColor, currentDepth) {
                const currentColor = maximizing ? aiColor : (aiColor==='r' ? 'b' : 'r');
                const moves = getAllValidMoves(boardState, currentColor);
                if (moves.length === 0) {
                    return maximizing ? -Infinity : Infinity;
                }
                if (depth === 0) return evaluateBoard(boardState, aiColor);

                const killers = killerMoves[currentDepth] || [null, null];
                moves.sort((a,b) => {
                    const aKiller = (killers[0] && a.fromX===killers[0].fromX && a.fromY===killers[0].fromY && a.toX===killers[0].toX && a.toY===killers[0].toY) ||
                                    (killers[1] && a.fromX===killers[1].fromX && a.fromY===killers[1].fromY && a.toX===killers[1].toX && a.toY===killers[1].toY);
                    const bKiller = (killers[0] && b.fromX===killers[0].fromX && b.fromY===killers[0].fromY && b.toX===killers[0].toX && b.toY===killers[0].toY) ||
                                    (killers[1] && b.fromX===killers[1].fromX && b.fromY===killers[1].fromY && b.toX===killers[1].toX && b.toY===killers[1].toY);
                    if (aKiller && !bKiller) return -1;
                    if (!aKiller && bKiller) return 1;
                    if (a.targetValue !== b.targetValue) return b.targetValue - a.targetValue;
                    return b.pieceValue - a.pieceValue;
                });

                if (maximizing) {
                    let maxEval = -Infinity;
                    for (let move of moves) {
                        const newBoard = applyMove(boardState, move.fromX, move.fromY, move.toX, move.toY);
                        const evalScore = alphaBeta(newBoard, depth-1, alpha, beta, false, aiColor, currentDepth+1);
                        maxEval = Math.max(maxEval, evalScore);
                        alpha = Math.max(alpha, evalScore);
                        if (beta <= alpha) {
                            if (move.targetValue === 0) {
                                if (!killerMoves[currentDepth]) killerMoves[currentDepth] = [null, null];
                                const k = killerMoves[currentDepth];
                                if (!k[0]) k[0] = move;
                                else if (!k[1] && !(k[0].fromX===move.fromX && k[0].fromY===move.fromY && k[0].toX===move.toX && k[0].toY===move.toY)) k[1] = move;
                            }
                            break;
                        }
                    }
                    return maxEval;
                } else {
                    let minEval = Infinity;
                    for (let move of moves) {
                        const newBoard = applyMove(boardState, move.fromX, move.fromY, move.toX, move.toY);
                        const evalScore = alphaBeta(newBoard, depth-1, alpha, beta, true, aiColor, currentDepth+1);
                        minEval = Math.min(minEval, evalScore);
                        beta = Math.min(beta, evalScore);
                        if (beta <= alpha) {
                            if (move.targetValue === 0) {
                                if (!killerMoves[currentDepth]) killerMoves[currentDepth] = [null, null];
                                const k = killerMoves[currentDepth];
                                if (!k[0]) k[0] = move;
                                else if (!k[1] && !(k[0].fromX===move.fromX && k[0].fromY===move.fromY && k[0].toX===move.toX && k[0].toY===move.toY)) k[1] = move;
                            }
                            break;
                        }
                    }
                    return minEval;
                }
            }

            function getBestMove(boardState, color, depth) {
                initKillers();
                const moves = getAllValidMoves(boardState, color);
                if (moves.length === 0) return null;
                let bestMoves = [];
                let bestScore = -Infinity;
                for (let move of moves) {
                    const newBoard = applyMove(boardState, move.fromX, move.fromY, move.toX, move.toY);
                    const score = alphaBeta(newBoard, depth-1, -Infinity, Infinity, false, color, 0);
                    if (score > bestScore) {
                        bestScore = score;
                        bestMoves = [move];
                    } else if (score === bestScore) {
                        bestMoves.push(move);
                    }
                }
                return bestMoves[Math.floor(Math.random() * bestMoves.length)];
            }

            function aiMakeMove(color) {
                if (gameOver || isAIPlaying) return;
                const isAITurn = (gameMode === 'ai-black' && color === 'b') || (gameMode === 'ai-red' && color === 'r');
                if (!isAITurn) return;

                isAIPlaying = true;
                setTimeout(() => {
                    if (gameOver) { isAIPlaying = false; return; }
                    const depth = aiDifficulty;
                    const bestMove = getBestMove(board, color, depth);
                    if (!bestMove) {
                        gameOver = true;
                        winner = (color === 'r') ? 'b' : 'r';
                        turnText.innerText = winner === 'r' ? '&#128308; 红方胜' : '&#9899; 黑方胜';
                        drawBoard();
                        isAIPlaying = false;
                        return;
                    }
                    const { fromX, fromY, toX, toY } = bestMove;
                    const boardCopy = board.map(row => row.map(cell => cell));
                    history.push({ board: boardCopy, currentPlayer, lastMoveFrom: [fromX,fromY], lastMoveTo: [toX,toY] });

                    const piece = board[fromX][fromY];
                    board[toX][toY] = piece;
                    board[fromX][fromY] = null;

                    const enemyColor = color === 'r' ? 'b' : 'r';
                    let enemyKingAlive = false;
                    for (let r=0; r<ROWS; r++) for (let c=0; c<COLS; c++) {
                        const p = board[r][c];
                        if (p && p[0]===enemyColor && p[1]==='k') enemyKingAlive = true;
                    }
                    if (!enemyKingAlive) {
                        gameOver = true;
                        winner = color;
                        turnText.innerText = winner === 'r' ? '红方胜' : '黑方胜';
                    } else {
                        currentPlayer = enemyColor;
                        turnText.innerText = currentPlayer === 'r' ? '红方走棋' : '黑方走棋';
                    }
                    selectedPiece = null;
                    drawBoard();

                    if (!gameOver) {
                        const nextIsAI = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
                        if (nextIsAI) {
                            setTimeout(() => { aiMakeMove(currentPlayer); }, 150);
                        }
                    }
                    isAIPlaying = false;
                }, 150);
            }

            function handleCanvasClick(e) {
                if (gameOver) return;
                const isCurrentAITurn = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
                if (isCurrentAITurn) return;

                const rect = canvas.getBoundingClientRect();
                const scaleX = canvas.width / rect.width;
                const scaleY = canvas.height / rect.height;
                const canvasX = (e.clientX - rect.left) * scaleX;
                const canvasY = (e.clientY - rect.top) * scaleY;
                const col = Math.round((canvasX - OFFSET_X) / GRID_SIZE);
                const row = Math.round((canvasY - OFFSET_Y) / GRID_SIZE);
                if (row<0 || row>=ROWS || col<0 || col>=COLS) return;

                if (!selectedPiece) {
                    const piece = board[row][col];
                    if (piece && piece[0] === currentPlayer) {
                        selectedPiece = { row, col, piece };
                    }
                } else {
                    const { row: sRow, col: sCol, piece: sPiece } = selectedPiece;
                    if (board[row][col] && board[row][col][0] === currentPlayer) {
                        selectedPiece = { row, col, piece: board[row][col] };
                        drawBoard();
                        return;
                    }
                    const rawMoves = getPieceRawMoves(board, sRow, sCol, sPiece);
                    let valid = false;
                    for (let m of rawMoves) {
                        if (m.toX === row && m.toY === col) {
                            const newBoard = applyMove(board, sRow, sCol, row, col);
                            if (!isKingInCheck(newBoard, currentPlayer) && !hasGeneralsFacing(newBoard)) {
                                valid = true;
                            }
                            break;
                        }
                    }
                    if (valid) {
                        const boardCopy = board.map(r => r.map(c => c));
                        history.push({ board: boardCopy, currentPlayer, lastMoveFrom: [sRow,sCol], lastMoveTo: [row,col] });

                        const piece = board[sRow][sCol];
                        board[row][col] = piece;
                        board[sRow][sCol] = null;

                        const enemyColor = currentPlayer === 'r' ? 'b' : 'r';
                        let enemyKingAlive = false;
                        for (let r=0; r<ROWS; r++) for (let c=0; c<COLS; c++) {
                            const p = board[r][c];
                            if (p && p[0]===enemyColor && p[1]==='k') enemyKingAlive = true;
                        }
                        if (!enemyKingAlive) {
                            gameOver = true;
                            winner = currentPlayer;
                            turnText.innerText = winner === 'r' ? '红方胜' : '黑方胜';
                        } else {
                            currentPlayer = enemyColor;
                            turnText.innerText = currentPlayer === 'r' ? '红方走棋' : '黑方走棋';
                        }
                        selectedPiece = null;
                        drawBoard();

                        if (!gameOver) {
                            const nextIsAI = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
                            if (nextIsAI) {
                                setTimeout(() => { aiMakeMove(currentPlayer); }, 200);
                            }
                        }
                    } else {
                        selectedPiece = null;
                    }
                }
                drawBoard();
            }

            function undoMove() {
                if (history.length === 0) return;
                if (isAIPlaying) return;
                const last = history.pop();
                board = last.board.map(row => row.map(cell => cell));
                currentPlayer = last.currentPlayer;
                selectedPiece = null;
                gameOver = false;
                winner = null;
                turnText.innerText = currentPlayer === 'r' ? '红方走棋' : '黑方走棋';
                drawBoard();
                if (!gameOver) {
                    const nextIsAI = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
                    if (nextIsAI) {
                        setTimeout(() => { aiMakeMove(currentPlayer); }, 200);
                    }
                }
            }

            function restartGame() {
                if (isAIPlaying) return;
                initBoard();
                drawBoard();
                if (gameMode === 'ai-black' && currentPlayer === 'b') aiMakeMove('b');
                else if (gameMode === 'ai-red' && currentPlayer === 'r') aiMakeMove('r');
            }

            canvas.addEventListener('click', handleCanvasClick);
            undoBtn.addEventListener('click', undoMove);
            restartBtn.addEventListener('click', restartGame);
            modeSelect.addEventListener('change', (e) => {
                gameMode = e.target.value;
                restartGame();
            });
            difficultySelect.addEventListener('change', (e) => {
                aiDifficulty = parseInt(e.target.value, 10);
            });

            initBoard();
            drawBoard();
        })();
    </script>
</body>
</html>

点评

Jcz777
复制代码，保存成html文件，编码选择UTF-8  详情 回复 发表于 11 小时前
it323
感谢分享！  详情 回复 发表于 12 小时前
yyz2191958
好人  发表于 12 小时前

评分

参与人数 2无忧币 +10 收起 理由
it323 + 5 很给力!
yyz2191958 + 5

查看全部评分

回复

使用道具 举报

发表于 12 小时前 | 显示全部楼层
没有权限上传附件
回复

使用道具 举报

sos
发表于 12 小时前 | 显示全部楼层
试用了，体验并不是很好，不如专业象棋应用
回复

使用道具 举报

发表于 12 小时前 | 显示全部楼层
懂一点玩的规则，但不会想很多步
回复

使用道具 举报

ebook
发表于 12 小时前 | 显示全部楼层
感谢分享。
回复

使用道具 举报

gah99sw
发表于 12 小时前 | 显示全部楼层
本帖最后由 gah99sw 于 2026-3-19 09:04 编辑

保存为ntf-8格式，否则乱码。下了一局，AI陪我下，丢了一个车，不能悔棋。
回复

使用道具 举报

it323
发表于 12 小时前 | 显示全部楼层
2013WCL 发表于 2026-3-19 08:43
我是热心网友

非常热
回复

使用道具 举报

it323
发表于 12 小时前 | 显示全部楼层
1e3e 发表于 2026-3-19 08:47
中国象棋专业版2.0
   
        * {

感谢分享！
回复

使用道具 举报

发表于 12 小时前 | 显示全部楼层
  1. <!DOCTYPE html>
  2. <html lang="zh">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <title>中国象棋专业版2.0</title>
  7.     <style>
  8.         * {
  9.             margin: 0;
  10.             padding: 0;
  11.             box-sizing: border-box;
  12.             user-select: none;
  13.         }
  14.         body {
  15.             background: #1a1a1a;
  16.             min-height: 100vh;
  17.             display: flex;
  18.             justify-content: center;
  19.             align-items: center;
  20.             font-family: '楷体', 'KaiTi', '华文楷体', serif;
  21.         }
  22.         .game-container {
  23.             background: transparent;
  24.             padding: 20px;
  25.             border-radius: 0;
  26.             box-shadow: none;
  27.             border: none;
  28.             display: flex;
  29.             gap: 40px;
  30.             align-items: center;
  31.         }
  32.         /* 强制canvas显示尺寸与像素尺寸一致，防止浏览器缩放导致模糊 */
  33.         canvas {
  34.             display: block;
  35.             width: 560px;
  36.             height: 630px;
  37.             border-radius: 18px;
  38.             box-shadow: 0 10px 20px rgba(0,0,0,0.3);
  39.             background: #f0d9b5;
  40.             cursor: pointer;
  41.         }
  42.         .right-panel {
  43.             display: flex;
  44.             flex-direction: column;
  45.             gap: 15px;
  46.             align-items: center;
  47.             justify-content: center;
  48.             min-width: 160px;
  49.         }
  50.         .turn-indicator {
  51.             background: #5e3e1e;
  52.             color: #f9eac3;
  53.             padding: 8px 12px;
  54.             border-radius: 50px;
  55.             font-size: 22px;
  56.             letter-spacing: 2px;
  57.             box-shadow: inset 0 -3px 0 #2f1f0e, 0 6px 10px black;
  58.             border-bottom: 2px solid #b5914c;
  59.             width: 100%;
  60.             text-align: center;
  61.             margin-bottom: 5px;
  62.         }
  63.         .mode-selector, .difficulty-selector {
  64.             background: #c29e5e;
  65.             border-radius: 40px;
  66.             padding: 8px 12px;
  67.             font-size: 20px;
  68.             font-weight: bold;
  69.             color: #2b1a0a;
  70.             border: 2px solid #efd39e;
  71.             box-shadow: inset 0 -2px 0 #6f4f2e, 0 6px 8px black;
  72.             cursor: pointer;
  73.             outline: none;
  74.             width: 100%;
  75.             text-align: center;
  76.         }
  77.         .action-btn {
  78.             background: #c29e5e;
  79.             border: none;
  80.             font-size: 22px;
  81.             font-family: '楷体', serif;
  82.             font-weight: bold;
  83.             padding: 8px 0;
  84.             border-radius: 40px;
  85.             color: #2b1a0a;
  86.             box-shadow: 0 8px 0 #6f4f2e, 0 10px 15px black;
  87.             cursor: pointer;
  88.             transition: 0.08s linear;
  89.             border: 1px solid #efd39e;
  90.             letter-spacing: 2px;
  91.             width: 100%;
  92.         }
  93.         .action-btn:active {
  94.             transform: translateY(7px);
  95.             box-shadow: 0 2px 0 #5a3f22, 0 8px 12px black;
  96.         }
  97.     </style>
  98. </head>
  99. <body>
  100.     <div class="game-container">
  101.         <canvas id="chessCanvas" width="560" height="630"></canvas>
  102.         <div class="right-panel">
  103.             <div class="turn-indicator" id="turnText">红方走棋</div>
  104.             <select id="modeSelect" class="mode-selector">
  105.                 <option value="human" selected>双人对战</option>
  106.                 <option value="ai-black">&#129302;AI执黑</option>
  107.                 <option value="ai-red">&#129302;AI执红</option>
  108.             </select>
  109.             <select id="difficultySelect" class="difficulty-selector">
  110.                 <option value="1">&#129302;初级1层</option>
  111.                 <option value="2" selected>&#129302;中级2层</option>
  112.                 <option value="3">&#129302;高级3层</option>
  113.             </select>
  114.             <button class="action-btn" id="undoBtn">悔棋</button>
  115.             <button class="action-btn restart-btn" id="restartBtn">新局</button>
  116.         </div>
  117.     </div>

  119.     <script>
  120.         (function() {
  121.             // ---------- 棋盘配置 ----------
  122.             const canvas = document.getElementById('chessCanvas');
  123.             const ctx = canvas.getContext('2d');
  124.             const turnText = document.getElementById('turnText');
  125.             const modeSelect = document.getElementById('modeSelect');
  126.             const difficultySelect = document.getElementById('difficultySelect');
  127.             const undoBtn = document.getElementById('undoBtn');
  128.             const restartBtn = document.getElementById('restartBtn');

  130.             const ROWS = 10;
  131.             const COLS = 9;
  132.             const GRID_SIZE = 56;
  133.             const OFFSET_X = 56;
  134.             const OFFSET_Y = 63;

  136.             // ---------- 全局状态 ----------
  137.             let board = [];
  138.             let currentPlayer = 'r';
  139.             let selectedPiece = null;
  140.             let gameOver = false;
  141.             let winner = null;               
  142.             let history = [];

  144.             // AI 相关
  145.             let gameMode = 'human';
  146.             let aiDifficulty = 2;
  147.             let isAIPlaying = false;

  149.             let killerMoves = [];
  150.             const MAX_DEPTH = 10;
  151.             function initKillers() {
  152.                 killerMoves = [];
  153.                 for (let d = 0; d <= MAX_DEPTH; d++) killerMoves[d] = [null, null];
  154.             }
  155.             initKillers();

  157.             const pieceValue = {
  158.                 'k': 10000, 'a': 200, 'b': 200, 'n': 500, 'r': 1000, 'c': 800, 'p': 100
  159.             };

  161.             function initBoard() {
  162.                 board = Array(ROWS).fill().map(() => Array(COLS).fill(null));

  164.                 board[0][0] = 'br'; board[0][1] = 'bn'; board[0][2] = 'bb'; board[0][3] = 'ba'; board[0][4] = 'bk';
  165.                 board[0][5] = 'ba'; board[0][6] = 'bb'; board[0][7] = 'bn'; board[0][8] = 'br';
  166.                 board[2][1] = 'bc'; board[2][7] = 'bc';
  167.                 board[3][0] = 'bp'; board[3][2] = 'bp'; board[3][4] = 'bp'; board[3][6] = 'bp'; board[3][8] = 'bp';

  169.                 board[9][0] = 'rr'; board[9][1] = 'rn'; board[9][2] = 'rb'; board[9][3] = 'ra'; board[9][4] = 'rk';
  170.                 board[9][5] = 'ra'; board[9][6] = 'rb'; board[9][7] = 'rn'; board[9][8] = 'rr';
  171.                 board[7][1] = 'rc'; board[7][7] = 'rc';
  172.                 board[6][0] = 'rp'; board[6][2] = 'rp'; board[6][4] = 'rp'; board[6][6] = 'rp'; board[6][8] = 'rp';

  174.                 currentPlayer = 'r';
  175.                 selectedPiece = null;
  176.                 gameOver = false;
  177.                 winner = null;
  178.                 history = [];
  179.                 turnText.innerText = '红方走棋';
  180.                 initKillers();
  181.             }

  183.             // ---------- 绘制函数 (锐化处理) ----------
  184.             function drawBoard() {
  185.                 ctx.clearRect(0, 0, canvas.width, canvas.height);
  186.                 drawGrid();
  187.                 drawPieces();
  188.                 if (selectedPiece) {
  189.                     const { row, col } = selectedPiece;
  190.                     // 选中高亮：坐标对齐到半像素，阴影调小
  191.                     ctx.save();
  192.                     ctx.strokeStyle = '#f5e56b';
  193.                     ctx.lineWidth = 3;
  194.                     ctx.shadowBlur = 6;          // 减小阴影模糊
  195.                     ctx.shadowColor = 'gold';
  196.                     ctx.beginPath();
  197.                     // 使用半像素坐标使圆弧边缘更清晰
  198.                     ctx.arc(OFFSET_X + col * GRID_SIZE + 0.5, OFFSET_Y + row * GRID_SIZE + 0.5, 24, 0, 2 * Math.PI);
  199.                     ctx.stroke();
  200.                     ctx.restore();
  201.                 }
  202.             }

  204.             function drawGrid() {
  205.                 ctx.save();
  206.                 ctx.strokeStyle = '#6b4f32';
  207.                 ctx.lineWidth = 1;               // 线宽设为1，配合半像素坐标获得锐利直线

  209.                 // 绘制横线 (坐标+0.5使线条精确覆盖像素)
  210.                 for (let i = 0; i < ROWS; i++) {
  211.                     ctx.beginPath();
  212.                     ctx.moveTo(OFFSET_X + 0.5, OFFSET_Y + i * GRID_SIZE + 0.5);
  213.                     ctx.lineTo(OFFSET_X + (COLS - 1) * GRID_SIZE + 0.5, OFFSET_Y + i * GRID_SIZE + 0.5);
  214.                     ctx.stroke();
  215.                 }
  216.                 // 绘制竖线
  217.                 for (let i = 0; i < COLS; i++) {
  218.                     ctx.beginPath();
  219.                     ctx.moveTo(OFFSET_X + i * GRID_SIZE + 0.5, OFFSET_Y + 0.5);
  220.                     ctx.lineTo(OFFSET_X + i * GRID_SIZE + 0.5, OFFSET_Y + (ROWS - 1) * GRID_SIZE + 0.5);
  221.                     ctx.stroke();
  222.                 }

  224.                 // 绘制楚河汉界 (半透明背景文字，稍微下移一点避开中线，保留原风格)
  225.                 ctx.font = '35px "楷体", "KaiTi"';
  226.                 ctx.fillStyle = '#4e2f15';
  227.                 ctx.globalAlpha = 0.3;
  228.                 const text = '楚 河   　    　汉 界';
  229.                 const textWidth = ctx.measureText(text).width;
  230.                 const boardLeft = OFFSET_X;
  231.                 const boardRight = OFFSET_X + (COLS - 1) * GRID_SIZE;
  232.                 const centerX = (boardLeft + boardRight) / 2;
  233.                 const textX = centerX - textWidth / 2;
  234.                 // 保持文字整数坐标防止模糊 (半透明背景无需锐利)
  235.                 ctx.fillText(text, textX, OFFSET_Y + 5 * GRID_SIZE - 13);
  236.                 ctx.globalAlpha = 1;

  238.                 // 九宫对角线 (同样用半像素坐标)
  239.                 ctx.beginPath();
  240.                 ctx.moveTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 0.5);
  241.                 ctx.lineTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 2 * GRID_SIZE + 0.5);
  242.                 ctx.stroke();
  243.                 ctx.beginPath();
  244.                 ctx.moveTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 0.5);
  245.                 ctx.lineTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 2 * GRID_SIZE + 0.5);
  246.                 ctx.stroke();

  248.                 ctx.beginPath();
  249.                 ctx.moveTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 7 * GRID_SIZE + 0.5);
  250.                 ctx.lineTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 9 * GRID_SIZE + 0.5);
  251.                 ctx.stroke();
  252.                 ctx.beginPath();
  253.                 ctx.moveTo(OFFSET_X + 5 * GRID_SIZE + 0.5, OFFSET_Y + 7 * GRID_SIZE + 0.5);
  254.                 ctx.lineTo(OFFSET_X + 3 * GRID_SIZE + 0.5, OFFSET_Y + 9 * GRID_SIZE + 0.5);
  255.                 ctx.stroke();

  257.                 // 绘制炮/兵/卒标记点 (使用半像素坐标，使圆点清晰)
  258.                 ctx.fillStyle = '#6b4f32';
  259.                 ctx.shadowBlur = 0; // 标记点不要阴影
  260.                 for (let r of [2, 7]) {
  261.                     for (let c of [1, 7]) {
  262.                         ctx.beginPath();
  263.                         ctx.arc(OFFSET_X + c * GRID_SIZE + 0.5, OFFSET_Y + r * GRID_SIZE + 0.5, 5, 0, 2 * Math.PI);
  264.                         ctx.fill();
  265.                     }
  266.                 }
  267.                 for (let r of [3, 6]) {
  268.                     for (let c of [0, 2, 4, 6, 8]) {
  269.                         ctx.beginPath();
  270.                         ctx.arc(OFFSET_X + c * GRID_SIZE + 0.5, OFFSET_Y + r * GRID_SIZE + 0.5, 4, 0, 2 * Math.PI);
  271.                         ctx.fill();
  272.                     }
  273.                 }
  274.                 ctx.restore();
  275.             }

  277.             function drawPieces() {
  278.                 for (let r = 0; r < ROWS; r++) {
  279.                     for (let c = 0; c < COLS; c++) {
  280.                         const piece = board[r][c];
  281.                         if (!piece) continue;
  282.                         // 圆心坐标对齐半像素，使棋子边缘清晰
  283.                         const x = OFFSET_X + c * GRID_SIZE + 0.5;
  284.                         const y = OFFSET_Y + r * GRID_SIZE + 0.5;

  286.                         ctx.save();
  287.                         // 棋子阴影减弱
  288.                         ctx.shadowColor = '#333';
  289.                         ctx.shadowBlur = 4;        // 原为8，减半减少模糊
  290.                         ctx.shadowOffsetY = 2;      // 原为3
  291.                         ctx.beginPath();
  292.                         ctx.arc(x, y, 24, 0, 2 * Math.PI);
  293.                         ctx.fillStyle = piece[0] === 'r' ? '#c33' : '#222';
  294.                         ctx.fill();
  295.                         ctx.shadowBlur = 2;          // 描边阴影稍弱
  296.                         ctx.strokeStyle = '#f1d28c';
  297.                         ctx.lineWidth = 2;
  298.                         ctx.stroke();

  300.                         // 绘制文字前清除阴影，保证文字清晰
  301.                         ctx.shadowBlur = 0;
  302.                         ctx.shadowOffsetY = 0;
  303.                         ctx.font = '35px "楷体", "KaiTi", "华文楷体", serif';
  304.                         ctx.fillStyle = piece[0] === 'r' ? '#FFD966' : '#ddd';
  305.                         ctx.textAlign = 'center';
  306.                         ctx.textBaseline = 'middle';
  307.                         // 微调偏移量，配合半像素圆心，文字仍保留轻微偏移以居中
  308.                         ctx.fillText(pieceToChinese(piece), x - 1, y + 5);
  309.                         ctx.restore();
  310.                     }
  311.                 }
  312.             }

  314.             function pieceToChinese(p) {
  315.                 const map = {
  316.                     'r': { 'k': '帅', 'a': '仕', 'b': '相', 'n': '马', 'r': '车', 'c': '炮', 'p': '兵' },
  317.                     'b': { 'k': '将', 'a': '士', 'b': '象', 'n': '马', 'r': '车', 'c': '炮', 'p': '卒' }
  318.                 };
  319.                 return map[p[0]][p[1]] || '?';
  320.             }

  322.             // ---------- 规则核心函数 (保持不变，保证AI逻辑正确) ----------
  323.             function getPieceRawMoves(boardState, row, col, piece) {
  324.                 const color = piece[0];
  325.                 const type = piece[1];
  326.                 const moves = [];

  328.                 if (type === 'k') {
  329.                     const palaceRows = (color === 'r') ? [7,8,9] : [0,1,2];
  330.                     const palaceCols = [3,4,5];
  331.                     const dirs = [[-1,0],[1,0],[0,-1],[0,1]];
  332.                     for (let [dx,dy] of dirs) {
  333.                         const nr = row+dx, nc = col+dy;
  334.                         if (palaceRows.includes(nr) && palaceCols.includes(nc)) {
  335.                             const target = boardState[nr]?.[nc];
  336.                             if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
  337.                         }
  338.                     }
  339.                 }
  340.                 else if (type === 'a') {
  341.                     const palaceRows = (color === 'r') ? [7,8,9] : [0,1,2];
  342.                     const palaceCols = [3,4,5];
  343.                     const dirs = [[-1,-1],[-1,1],[1,-1],[1,1]];
  344.                     for (let [dx,dy] of dirs) {
  345.                         const nr = row+dx, nc = col+dy;
  346.                         if (palaceRows.includes(nr) && palaceCols.includes(nc)) {
  347.                             const target = boardState[nr]?.[nc];
  348.                             if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
  349.                         }
  350.                     }
  351.                 }
  352.                 else if (type === 'b') {
  353.                     const dirs = [[-2,-2],[-2,2],[2,-2],[2,2]];
  354.                     for (let [dx,dy] of dirs) {
  355.                         const nr = row+dx, nc = col+dy;
  356.                         if (nr<0 || nr>=ROWS || nc<0 || nc>=COLS) continue;
  357.                         if (color === 'r' && nr < 5) continue;
  358.                         if (color === 'b' && nr > 4) continue;
  359.                         const eyeRow = row + dx/2, eyeCol = col + dy/2;
  360.                         if (boardState[eyeRow][eyeCol] !== null) continue;
  361.                         const target = boardState[nr][nc];
  362.                         if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
  363.                     }
  364.                 }
  365.                 else if (type === 'n') {
  366.                     const jumps = [[-2,-1],[-2,1],[-1,-2],[-1,2],[1,-2],[1,2],[2,-1],[2,1]];
  367.                     for (let [dx,dy] of jumps) {
  368.                         const nr = row+dx, nc = col+dy;
  369.                         if (nr<0 || nr>=ROWS || nc<0 || nc>=COLS) continue;
  370.                         let blockRow = row, blockCol = col;
  371.                         if (Math.abs(dx) === 2) { blockRow = row + (dx>0?1:-1); blockCol = col; }
  372.                         else { blockRow = row; blockCol = col + (dy>0?1:-1); }
  373.                         if (boardState[blockRow][blockCol] !== null) continue;
  374.                         const target = boardState[nr][nc];
  375.                         if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
  376.                     }
  377.                 }
  378.                 else if (type === 'r') {
  379.                     const dirs = [[-1,0],[1,0],[0,-1],[0,1]];
  380.                     for (let [dx,dy] of dirs) {
  381.                         let nr = row+dx, nc = col+dy;
  382.                         while (nr>=0 && nr<ROWS && nc>=0 && nc<COLS) {
  383.                             const target = boardState[nr][nc];
  384.                             if (!target) moves.push({toX:nr, toY:nc});
  385.                             else {
  386.                                 if (target[0] !== color) moves.push({toX:nr, toY:nc});
  387.                                 break;
  388.                             }
  389.                             nr += dx; nc += dy;
  390.                         }
  391.                     }
  392.                 }
  393.                 else if (type === 'c') {
  394.                     const dirs = [[-1,0],[1,0],[0,-1],[0,1]];
  395.                     for (let [dx,dy] of dirs) {
  396.                         let nr = row+dx, nc = col+dy;
  397.                         let foundObstacle = false;
  398.                         while (nr>=0 && nr<ROWS && nc>=0 && nc<COLS) {
  399.                             const target = boardState[nr][nc];
  400.                             if (!foundObstacle) {
  401.                                 if (!target) moves.push({toX:nr, toY:nc});
  402.                                 else foundObstacle = true;
  403.                             } else {
  404.                                 if (target && target[0] !== color) {
  405.                                     moves.push({toX:nr, toY:nc});
  406.                                     break;
  407.                                 } else if (target) break;
  408.                             }
  409.                             nr += dx; nc += dy;
  410.                         }
  411.                     }
  412.                 }
  413.                 else if (type === 'p') {
  414.                     const forward = (color === 'r') ? -1 : 1;
  415.                     let nr = row + forward, nc = col;
  416.                     if (nr>=0 && nr<ROWS) {
  417.                         const target = boardState[nr][nc];
  418.                         if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
  419.                     }
  420.                     const crossed = (color === 'r') ? row <= 4 : row >= 5;
  421.                     if (crossed) {
  422.                         for (let dc of [-1,1]) {
  423.                             nr = row; nc = col + dc;
  424.                             if (nc>=0 && nc<COLS) {
  425.                                 const target = boardState[nr][nc];
  426.                                 if (!target || target[0] !== color) moves.push({toX:nr, toY:nc});
  427.                             }
  428.                         }
  429.                     }
  430.                 }
  431.                 return moves;
  432.             }

  434.             function applyMove(boardState, fromX, fromY, toX, toY) {
  435.                 const newBoard = boardState.map(row => row.map(cell => cell));
  436.                 const piece = newBoard[fromX][fromY];
  437.                 newBoard[toX][toY] = piece;
  438.                 newBoard[fromX][fromY] = null;
  439.                 return newBoard;
  440.             }

  442.             function isKingInCheck(boardState, color) {
  443.                 let kingPos = null;
  444.                 for (let r=0; r<ROWS; r++) {
  445.                     for (let c=0; c<COLS; c++) {
  446.                         const p = boardState[r][c];
  447.                         if (p && p[0]===color && p[1]==='k') kingPos = [r,c];
  448.                     }
  449.                 }
  450.                 if (!kingPos) return false;
  451.                 const opponent = color==='r' ? 'b' : 'r';
  452.                 for (let r=0; r<ROWS; r++) {
  453.                     for (let c=0; c<COLS; c++) {
  454.                         const p = boardState[r][c];
  455.                         if (p && p[0]===opponent) {
  456.                             const rawMoves = getPieceRawMoves(boardState, r, c, p);
  457.                             for (let m of rawMoves) {
  458.                                 if (m.toX === kingPos[0] && m.toY === kingPos[1]) return true;
  459.                             }
  460.                         }
  461.                     }
  462.                 }
  463.                 return false;
  464.             }

  466.             function hasGeneralsFacing(boardState) {
  467.                 let redKing = null, blackKing = null;
  468.                 for (let r=0; r<ROWS; r++) {
  469.                     for (let c=0; c<COLS; c++) {
  470.                         const p = boardState[r][c];
  471.                         if (p && p[1]==='k') {
  472.                             if (p[0]==='r') redKing = [r,c];
  473.                             else blackKing = [r,c];
  474.                         }
  475.                     }
  476.                 }
  477.                 if (!redKing || !blackKing) return false;
  478.                 if (redKing[1] !== blackKing[1]) return false;
  479.                 const col = redKing[1];
  480.                 const minRow = Math.min(redKing[0], blackKing[0]);
  481.                 const maxRow = Math.max(redKing[0], blackKing[0]);
  482.                 for (let r = minRow+1; r < maxRow; r++) {
  483.                     if (boardState[r][col] !== null) return false;
  484.                 }
  485.                 return true;
  486.             }

  488.             function getAllValidMoves(boardState, color) {
  489.                 const moves = [];
  490.                 for (let r=0; r<ROWS; r++) {
  491.                     for (let c=0; c<COLS; c++) {
  492.                         const piece = boardState[r][c];
  493.                         if (!piece || piece[0] !== color) continue;
  494.                         const raw = getPieceRawMoves(boardState, r, c, piece);
  495.                         for (let m of raw) {
  496.                             const newBoard = applyMove(boardState, r, c, m.toX, m.toY);
  497.                             if (isKingInCheck(newBoard, color)) continue;
  498.                             if (hasGeneralsFacing(newBoard)) continue;
  499.                             const pieceVal = pieceValue[piece[1]] || 0;
  500.                             const target = boardState[m.toX][m.toY];
  501.                             const targetVal = target ? (pieceValue[target[1]] || 0) : 0;
  502.                             moves.push({
  503.                                 fromX: r, fromY: c,
  504.                                 toX: m.toX, toY: m.toY,
  505.                                 pieceValue: pieceVal, targetValue: targetVal
  506.                             });
  507.                         }
  508.                     }
  509.                 }
  510.                 return moves;
  511.             }

  513.             function evaluateBoard(boardState, perspective) {
  514.                 let score = 0;
  515.                 for (let r=0; r<ROWS; r++) {
  516.                     for (let c=0; c<COLS; c++) {
  517.                         const p = boardState[r][c];
  518.                         if (!p) continue;
  519.                         const val = pieceValue[p[1]] || 0;
  520.                         if (p[0] === perspective) score += val;
  521.                         else score -= val;
  522.                     }
  523.                 }
  524.                 return score;
  525.             }

  527.             function alphaBeta(boardState, depth, alpha, beta, maximizing, aiColor, currentDepth) {
  528.                 const currentColor = maximizing ? aiColor : (aiColor==='r' ? 'b' : 'r');
  529.                 const moves = getAllValidMoves(boardState, currentColor);
  530.                 if (moves.length === 0) {
  531.                     return maximizing ? -Infinity : Infinity;
  532.                 }
  533.                 if (depth === 0) return evaluateBoard(boardState, aiColor);

  535.                 const killers = killerMoves[currentDepth] || [null, null];
  536.                 moves.sort((a,b) => {
  537.                     const aKiller = (killers[0] && a.fromX===killers[0].fromX && a.fromY===killers[0].fromY && a.toX===killers[0].toX && a.toY===killers[0].toY) ||
  538.                                     (killers[1] && a.fromX===killers[1].fromX && a.fromY===killers[1].fromY && a.toX===killers[1].toX && a.toY===killers[1].toY);
  539.                     const bKiller = (killers[0] && b.fromX===killers[0].fromX && b.fromY===killers[0].fromY && b.toX===killers[0].toX && b.toY===killers[0].toY) ||
  540.                                     (killers[1] && b.fromX===killers[1].fromX && b.fromY===killers[1].fromY && b.toX===killers[1].toX && b.toY===killers[1].toY);
  541.                     if (aKiller && !bKiller) return -1;
  542.                     if (!aKiller && bKiller) return 1;
  543.                     if (a.targetValue !== b.targetValue) return b.targetValue - a.targetValue;
  544.                     return b.pieceValue - a.pieceValue;
  545.                 });

  547.                 if (maximizing) {
  548.                     let maxEval = -Infinity;
  549.                     for (let move of moves) {
  550.                         const newBoard = applyMove(boardState, move.fromX, move.fromY, move.toX, move.toY);
  551.                         const evalScore = alphaBeta(newBoard, depth-1, alpha, beta, false, aiColor, currentDepth+1);
  552.                         maxEval = Math.max(maxEval, evalScore);
  553.                         alpha = Math.max(alpha, evalScore);
  554.                         if (beta <= alpha) {
  555.                             if (move.targetValue === 0) {
  556.                                 if (!killerMoves[currentDepth]) killerMoves[currentDepth] = [null, null];
  557.                                 const k = killerMoves[currentDepth];
  558.                                 if (!k[0]) k[0] = move;
  559.                                 else if (!k[1] && !(k[0].fromX===move.fromX && k[0].fromY===move.fromY && k[0].toX===move.toX && k[0].toY===move.toY)) k[1] = move;
  560.                             }
  561.                             break;
  562.                         }
  563.                     }
  564.                     return maxEval;
  565.                 } else {
  566.                     let minEval = Infinity;
  567.                     for (let move of moves) {
  568.                         const newBoard = applyMove(boardState, move.fromX, move.fromY, move.toX, move.toY);
  569.                         const evalScore = alphaBeta(newBoard, depth-1, alpha, beta, true, aiColor, currentDepth+1);
  570.                         minEval = Math.min(minEval, evalScore);
  571.                         beta = Math.min(beta, evalScore);
  572.                         if (beta <= alpha) {
  573.                             if (move.targetValue === 0) {
  574.                                 if (!killerMoves[currentDepth]) killerMoves[currentDepth] = [null, null];
  575.                                 const k = killerMoves[currentDepth];
  576.                                 if (!k[0]) k[0] = move;
  577.                                 else if (!k[1] && !(k[0].fromX===move.fromX && k[0].fromY===move.fromY && k[0].toX===move.toX && k[0].toY===move.toY)) k[1] = move;
  578.                             }
  579.                             break;
  580.                         }
  581.                     }
  582.                     return minEval;
  583.                 }
  584.             }

  586.             function getBestMove(boardState, color, depth) {
  587.                 initKillers();
  588.                 const moves = getAllValidMoves(boardState, color);
  589.                 if (moves.length === 0) return null;
  590.                 let bestMoves = [];
  591.                 let bestScore = -Infinity;
  592.                 for (let move of moves) {
  593.                     const newBoard = applyMove(boardState, move.fromX, move.fromY, move.toX, move.toY);
  594.                     const score = alphaBeta(newBoard, depth-1, -Infinity, Infinity, false, color, 0);
  595.                     if (score > bestScore) {
  596.                         bestScore = score;
  597.                         bestMoves = [move];
  598.                     } else if (score === bestScore) {
  599.                         bestMoves.push(move);
  600.                     }
  601.                 }
  602.                 return bestMoves[Math.floor(Math.random() * bestMoves.length)];
  603.             }

  605.             function aiMakeMove(color) {
  606.                 if (gameOver || isAIPlaying) return;
  607.                 const isAITurn = (gameMode === 'ai-black' && color === 'b') || (gameMode === 'ai-red' && color === 'r');
  608.                 if (!isAITurn) return;

  610.                 isAIPlaying = true;
  611.                 setTimeout(() => {
  612.                     if (gameOver) { isAIPlaying = false; return; }
  613.                     const depth = aiDifficulty;
  614.                     const bestMove = getBestMove(board, color, depth);
  615.                     if (!bestMove) {
  616.                         gameOver = true;
  617.                         winner = (color === 'r') ? 'b' : 'r';
  618.                         turnText.innerText = winner === 'r' ? '&#128308; 红方胜' : '&#9899; 黑方胜';
  619.                         drawBoard();
  620.                         isAIPlaying = false;
  621.                         return;
  622.                     }
  623.                     const { fromX, fromY, toX, toY } = bestMove;
  624.                     const boardCopy = board.map(row => row.map(cell => cell));
  625.                     history.push({ board: boardCopy, currentPlayer, lastMoveFrom: [fromX,fromY], lastMoveTo: [toX,toY] });

  627.                     const piece = board[fromX][fromY];
  628.                     board[toX][toY] = piece;
  629.                     board[fromX][fromY] = null;

  631.                     const enemyColor = color === 'r' ? 'b' : 'r';
  632.                     let enemyKingAlive = false;
  633.                     for (let r=0; r<ROWS; r++) for (let c=0; c<COLS; c++) {
  634.                         const p = board[r][c];
  635.                         if (p && p[0]===enemyColor && p[1]==='k') enemyKingAlive = true;
  636.                     }
  637.                     if (!enemyKingAlive) {
  638.                         gameOver = true;
  639.                         winner = color;
  640.                         turnText.innerText = winner === 'r' ? '红方胜' : '黑方胜';
  641.                     } else {
  642.                         currentPlayer = enemyColor;
  643.                         turnText.innerText = currentPlayer === 'r' ? '红方走棋' : '黑方走棋';
  644.                     }
  645.                     selectedPiece = null;
  646.                     drawBoard();

  648.                     if (!gameOver) {
  649.                         const nextIsAI = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
  650.                         if (nextIsAI) {
  651.                             setTimeout(() => { aiMakeMove(currentPlayer); }, 150);
  652.                         }
  653.                     }
  654.                     isAIPlaying = false;
  655.                 }, 150);
  656.             }

  658.             function handleCanvasClick(e) {
  659.                 if (gameOver) return;
  660.                 const isCurrentAITurn = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
  661.                 if (isCurrentAITurn) return;

  663.                 const rect = canvas.getBoundingClientRect();
  664.                 const scaleX = canvas.width / rect.width;
  665.                 const scaleY = canvas.height / rect.height;
  666.                 const canvasX = (e.clientX - rect.left) * scaleX;
  667.                 const canvasY = (e.clientY - rect.top) * scaleY;
  668.                 const col = Math.round((canvasX - OFFSET_X) / GRID_SIZE);
  669.                 const row = Math.round((canvasY - OFFSET_Y) / GRID_SIZE);
  670.                 if (row<0 || row>=ROWS || col<0 || col>=COLS) return;

  672.                 if (!selectedPiece) {
  673.                     const piece = board[row][col];
  674.                     if (piece && piece[0] === currentPlayer) {
  675.                         selectedPiece = { row, col, piece };
  676.                     }
  677.                 } else {
  678.                     const { row: sRow, col: sCol, piece: sPiece } = selectedPiece;
  679.                     if (board[row][col] && board[row][col][0] === currentPlayer) {
  680.                         selectedPiece = { row, col, piece: board[row][col] };
  681.                         drawBoard();
  682.                         return;
  683.                     }
  684.                     const rawMoves = getPieceRawMoves(board, sRow, sCol, sPiece);
  685.                     let valid = false;
  686.                     for (let m of rawMoves) {
  687.                         if (m.toX === row && m.toY === col) {
  688.                             const newBoard = applyMove(board, sRow, sCol, row, col);
  689.                             if (!isKingInCheck(newBoard, currentPlayer) && !hasGeneralsFacing(newBoard)) {
  690.                                 valid = true;
  691.                             }
  692.                             break;
  693.                         }
  694.                     }
  695.                     if (valid) {
  696.                         const boardCopy = board.map(r => r.map(c => c));
  697.                         history.push({ board: boardCopy, currentPlayer, lastMoveFrom: [sRow,sCol], lastMoveTo: [row,col] });

  699.                         const piece = board[sRow][sCol];
  700.                         board[row][col] = piece;
  701.                         board[sRow][sCol] = null;

  703.                         const enemyColor = currentPlayer === 'r' ? 'b' : 'r';
  704.                         let enemyKingAlive = false;
  705.                         for (let r=0; r<ROWS; r++) for (let c=0; c<COLS; c++) {
  706.                             const p = board[r][c];
  707.                             if (p && p[0]===enemyColor && p[1]==='k') enemyKingAlive = true;
  708.                         }
  709.                         if (!enemyKingAlive) {
  710.                             gameOver = true;
  711.                             winner = currentPlayer;
  712.                             turnText.innerText = winner === 'r' ? '红方胜' : '黑方胜';
  713.                         } else {
  714.                             currentPlayer = enemyColor;
  715.                             turnText.innerText = currentPlayer === 'r' ? '红方走棋' : '黑方走棋';
  716.                         }
  717.                         selectedPiece = null;
  718.                         drawBoard();

  720.                         if (!gameOver) {
  721.                             const nextIsAI = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
  722.                             if (nextIsAI) {
  723.                                 setTimeout(() => { aiMakeMove(currentPlayer); }, 200);
  724.                             }
  725.                         }
  726.                     } else {
  727.                         selectedPiece = null;
  728.                     }
  729.                 }
  730.                 drawBoard();
  731.             }

  733.             function undoMove() {
  734.                 if (history.length === 0) return;
  735.                 if (isAIPlaying) return;
  736.                 const last = history.pop();
  737.                 board = last.board.map(row => row.map(cell => cell));
  738.                 currentPlayer = last.currentPlayer;
  739.                 selectedPiece = null;
  740.                 gameOver = false;
  741.                 winner = null;
  742.                 turnText.innerText = currentPlayer === 'r' ? '红方走棋' : '黑方走棋';
  743.                 drawBoard();
  744.                 if (!gameOver) {
  745.                     const nextIsAI = (gameMode === 'ai-black' && currentPlayer === 'b') || (gameMode === 'ai-red' && currentPlayer === 'r');
  746.                     if (nextIsAI) {
  747.                         setTimeout(() => { aiMakeMove(currentPlayer); }, 200);
  748.                     }
  749.                 }
  750.             }

  752.             function restartGame() {
  753.                 if (isAIPlaying) return;
  754.                 initBoard();
  755.                 drawBoard();
  756.                 if (gameMode === 'ai-black' && currentPlayer === 'b') aiMakeMove('b');
  757.                 else if (gameMode === 'ai-red' && currentPlayer === 'r') aiMakeMove('r');
  758.             }

  760.             canvas.addEventListener('click', handleCanvasClick);
  761.             undoBtn.addEventListener('click', undoMove);
  762.             restartBtn.addEventListener('click', restartGame);
  763.             modeSelect.addEventListener('change', (e) => {
  764.                 gameMode = e.target.value;
  765.                 restartGame();
  766.             });
  767.             difficultySelect.addEventListener('change', (e) => {
  768.                 aiDifficulty = parseInt(e.target.value, 10);
  769.             });

  771.             initBoard();
  772.             drawBoard();
  773.         })();
  774.     </script>
  775. </body>
  776. </html>
复制代码

点评

yyz2191958
好人  发表于 12 小时前
sxlh2311
复制代码，打开记事本，粘贴，改扩展名为html，双击运行  详情 回复 发表于 12 小时前

评分

参与人数 1无忧币 +5 收起 理由
yyz2191958 + 5

查看全部评分

回复

使用道具 举报

发表于 12 小时前 | 显示全部楼层
sxlh2311 发表于 2026-3-19 09:18

复制代码，打开记事本，粘贴，改扩展名为html，双击运行
回复

使用道具 举报

发表于 11 小时前 | 显示全部楼层
支持3#分享
回复

使用道具 举报

Jcz777
发表于 11 小时前 | 显示全部楼层
1e3e 发表于 2026-3-19 08:47
中国象棋专业版2.0
   
        * {

复制代码，保存成html文件，编码选择UTF-8
回复

使用道具 举报

dcll
发表于 11 小时前 | 显示全部楼层
热心网友确实厉害！
回复

使用道具 举报

lodon
发表于 11 小时前 | 显示全部楼层
高手在民间
回复

使用道具 举报

hfzym
发表于 11 小时前 | 显示全部楼层
水平太差，高级三层都下不过我……
回复

使用道具 举报

发表于 11 小时前 | 显示全部楼层
要是链接着某个ai啥的还行，单机的就没什么好奇心了。
回复

使用道具 举报

tan8388
发表于 11 小时前 | 显示全部楼层
感谢分享！
回复

使用道具 举报

snow99
发表于 10 小时前 | 显示全部楼层
在线玩中国象棋
https://xiangqi.taadis.com/
这个棋力可以
回复

使用道具 举报

a66
发表于 10 小时前 | 显示全部楼层
中国象棋专业版2.0：http://4275.com/3ny0xc
回复

使用道具 举报

发表于 10 小时前 | 显示全部楼层
棋子丑，人机对战，机器完全没水平，瞎走棋，别求了！
回复

使用道具 举报

shawn.c@
发表于 10 小时前 | 显示全部楼层
打开是乱码
回复

使用道具 举报

发表于 9 小时前 | 显示全部楼层
感谢分享
回复

使用道具 举报

发表于 9 小时前 | 显示全部楼层
AI执红，第一步居然是帅五进一~~
回复

使用道具 举报

gogo177
发表于 8 小时前 | 显示全部楼层
html的能力也这么好了
回复

使用道具 举报

guong
发表于 6 小时前 | 显示全部楼层
谢谢3楼热心网友
回复

使用道具 举报

sdb5168
发表于 6 小时前 | 显示全部楼层
感谢分享
回复

使用道具 举报

发表于 3 小时前 | 显示全部楼层
我的帖子这么火？！今天我在研究中国象棋，弄好了再分享给大家。
回复

使用道具 举报

12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

QQ|小黑屋|手机版|Archiver|捐助支持|无忧启动 ( 闽ICP备05002490号-1|闽公网安备35020302032614号 )

GMT+8, 2026-3-19 21:37

Powered by Discuz! X3.5

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表