象棋代码（AI做的）

#include <iostream>
#include <string>
#include <windows.h>
#include <conio.h>

using namespace std;

// 棋盘尺寸
const int BOARD_ROWS = 10;
const int BOARD_COLS = 9;

// 棋子类型枚举
enum PieceType {
EMPTY = 0,
R_SHUAI = 1, R_SHI = 2, R_XIANG = 3, R_MA = 4,
R_CHE = 5, R_PAO = 6, R_BING = 7,
B_JIANG = -1, B_SHI = -2, B_XIANG = -3, B_MA = -4,
B_CHE = -5, B_PAO = -6, B_ZU = -7
};

// 控制台颜色常量
const int COLOR_RED = 12; // 红方棋子：亮红色
const int COLOR_BLACK = 11; // 黑方棋子：亮青色
const int COLOR_WHITE = 15; // 边框与坐标：亮白色
const int COLOR_YELLOW = 14; // 标题与提示：亮黄色
const int COLOR_GREEN = 10; // 楚河汉界：亮绿色

// 游戏状态常量
const int STATE_SELECT_PIECE = 0; // 选择棋子状态
const int STATE_SELECT_TARGET = 1; // 选择目标状态

// ==================== 控制台辅助函数【新增，解决闪烁】 ====================
void GotoXY(int x, int y)
{
COORD pos;
pos.X = x;
pos.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}

// ==================== 棋子类 ====================

class Piece {
public:
int type, row, col;
Piece(int t = EMPTY, int r = 0, int c = 0) : type(t), row(r), col(c) {}

bool isRed() const { return type > 0; }
bool isBlack() const { return type < 0; }
bool isEmpty() const { return type == EMPTY; }

const char* getChar() const {
    switch (type) {
    case R_SHUAI: return "\xCB\xA7"; // 帅
    case R_SHI:   return "\xCA\xCB"; // 仕
    case R_XIANG: return "\xCF\xE0"; // 相
    case R_MA:    return "\xC2\xED"; // 马
    case R_CHE:   return "\xB3\xB5"; // 车
    case R_PAO:   return "\xC5\xDA"; // 炮
    case R_BING:  return "\xB1\xF8"; // 兵
    case B_JIANG: return "\xBD\xAB"; // 将
    case B_SHI:   return "\xCA\xBF"; // 士
    case B_XIANG: return "\xCF\xF3"; // 象
    case B_MA:    return "\xC2\xED"; // 马
    case B_CHE:   return "\xB3\xB5"; // 车
    case B_PAO:   return "\xC5\xDA"; // 炮
    case B_ZU:    return "\xD7\xE4"; // 卒
    default:      return "  ";
    }
}

int getColor() const {
    if (isRed()) return COLOR_RED;
    if (isBlack()) return COLOR_BLACK;
    return COLOR_WHITE;
}

};

// ==================== 棋盘类 ====================

class Board {
private:
Piece board[BOARD_ROWS][BOARD_COLS];

public:
Board() { initBoard(); }

void initBoard() {
    for (int i = 0; i < BOARD_ROWS; i++)
        for (int j = 0; j < BOARD_COLS; j++)
            board[i][j] = Piece(EMPTY, i, j);

    board[0][0] = Piece(R_CHE, 0, 0);
    board[0][1] = Piece(R_MA, 0, 1);
    board[0][2] = Piece(R_XIANG, 0, 2);
    board[0][3] = Piece(R_SHI, 0, 3);
    board[0][4] = Piece(R_SHUAI, 0, 4);
    board[0][5] = Piece(R_SHI, 0, 5);
    board[0][6] = Piece(R_XIANG, 0, 6);
    board[0][7] = Piece(R_MA, 0, 7);
    board[0][8] = Piece(R_CHE, 0, 8);
    board[2][1] = Piece(R_PAO, 2, 1);
    board[2][7] = Piece(R_PAO, 2, 7);
    board[3][0] = Piece(R_BING, 3, 0);
    board[3][2] = Piece(R_BING, 3, 2);
    board[3][4] = Piece(R_BING, 3, 4);
    board[3][6] = Piece(R_BING, 3, 6);
    board[3][8] = Piece(R_BING, 3, 8);

    board[9][0] = Piece(B_CHE, 9, 0);
    board[9][1] = Piece(B_MA, 9, 1);
    board[9][2] = Piece(B_XIANG, 9, 2);
    board[9][3] = Piece(B_SHI, 9, 3);
    board[9][4] = Piece(B_JIANG, 9, 4);
    board[9][5] = Piece(B_SHI, 9, 5);
    board[9][6] = Piece(B_XIANG, 9, 6);
    board[9][7] = Piece(B_MA, 9, 7);
    board[9][8] = Piece(B_CHE, 9, 8);
    board[7][1] = Piece(B_PAO, 7, 1);
    board[7][7] = Piece(B_PAO, 7, 7);
    board[6][0] = Piece(B_ZU, 6, 0);
    board[6][2] = Piece(B_ZU, 6, 2);
    board[6][4] = Piece(B_ZU, 6, 4);
    board[6][6] = Piece(B_ZU, 6, 6);
    board[6][8] = Piece(B_ZU, 6, 8);
}

Piece& getPiece(int r, int c) { return board[r][c]; }
const Piece& getPiece(int r, int c) const { return board[r][c]; }

bool isValidPos(int r, int c) const {
    return r >= 0 && r < BOARD_ROWS && c >= 0 && c < BOARD_COLS;
}

bool isInPalace(int r, int c, bool red) const {
    if (c < 3 || c > 5) return false;
    return red ? (r >= 0 && r <= 2) : (r >= 7 && r <= 9);
}

bool hasCrossedRiver(int r, bool red) const {
    return red ? (r > 4) : (r < 5);
}

bool findKing(bool findRed, int &r, int &c) const {
    int target = findRed ? R_SHUAI : B_JIANG;
    for (int i = 0; i < BOARD_ROWS; i++)
        for (int j = 0; j < BOARD_COLS; j++)
            if (board[i][j].type == target) { r = i; c = j; return true; }
    return false;
}

bool movePiece(int fr, int fc, int tr, int tc) {
    if (!isValidPos(fr, fc) || !isValidPos(tr, tc)) return false;
    board[tr][tc] = board[fr][fc];
    board[tr][tc].row = tr; board[tr][tc].col = tc;
    board[fr][fc] = Piece(EMPTY, fr, fc);
    return true;
}

void setColor(int color) const {
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);
}

void print(int cursorR, int cursorC, int state, int fromR, int fromC,
    const bool hints[BOARD_ROWS][BOARD_COLS]) const {
    // 不再清屏！直接光标回到左上角局部刷新，消除闪烁
    GotoXY(0, 0);
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);

    setColor(COLOR_YELLOW);
    cout << "\n";
    cout << "    ===========================================\n";
    cout << "              中  国  象  棋\n";
    cout << "    ===========================================\n\n";

    setColor(COLOR_WHITE);
    cout << "      ";
    for (int j = 0; j < BOARD_COLS; j++) {
        cout << " " << j << "  ";
    }
    cout << "\n";
    cout << "     +---+---+---+---+---+---+---+---+---+\n";

    for (int i = 0; i < BOARD_ROWS; i++) {
        setColor(COLOR_WHITE);
        cout << "  " << i << "  ";

        for (int j = 0; j < BOARD_COLS; j++) {
            cout << "|";

            int hl = 0;
            if (i == cursorR && j == cursorC) hl = 3;
            else if (state == STATE_SELECT_TARGET && i == fromR && j == fromC) hl = 2;
            else if (hints && hints[i][j]) hl = 1;

            const Piece &p = board[i][j];
            string content;
            WORD normalAttr = COLOR_WHITE;

            if (p.isEmpty()) {
                if (i == 4 || i == 5) {
                    if (j == 1) { content = "\xB3\xFE "; normalAttr = COLOR_GREEN; }
                    else if (j == 2) { content = "\xBA\xD3 "; normalAttr = COLOR_GREEN; }
                    else if (j == 6) { content = "\xBA\xBA "; normalAttr = COLOR_GREEN; }
                    else if (j == 7) { content = "\xBD\xE7 "; normalAttr = COLOR_GREEN; }
                    else { content = "   "; }
                }
                else {
                    content = "   ";
                }
            }
            else {
                content = string(p.getChar()) + " ";
                normalAttr = p.getColor();
            }

            if (hl > 0) {
                WORD bg = 0;
                if (hl == 1) bg = BACKGROUND_GREEN | BACKGROUND_INTENSITY;
                else if (hl == 2) bg = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY;
                else if (hl == 3) bg = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_INTENSITY;
                SetConsoleTextAttribute(h, 0 | bg);
            }
            else {
                setColor(normalAttr);
            }

            cout << content;
            setColor(COLOR_WHITE);
        }

        cout << "| " << i << "\n";

        if (i < BOARD_ROWS - 1) {
            cout << "     +---+---+---+---+---+---+---+---+---+\n";
        }
    }

    cout << "     +---+---+---+---+---+---+---+---+---+\n";
    cout << "      ";
    for (int j = 0; j < BOARD_COLS; j++) {
        cout << " " << j << "  ";
    }
    cout << "\n\n";

    setColor(COLOR_RED);
    cout << "    [红方] ";
    setColor(COLOR_BLACK);
    cout << "[黑方] ";
    setColor(COLOR_WHITE);
    cout << "  [WASD]移动 [空格]确认 [ESC]返回 [Q]退出 [R]重来\n\n";
}

};

// ==================== 规则验证类 ====================

class RuleChecker {
private:
Board &board;

public:
RuleChecker(Board &b) : board(b) {}

// 基本走法验证（不检测送将，用于绿色提示显示）
bool isBasicValidMove(int fr, int fc, int tr, int tc, bool redTurn) {
    if (!board.isValidPos(fr, fc) || !board.isValidPos(tr, tc)) return false;

    Piece &from = board.getPiece(fr, fc);
    Piece &to = board.getPiece(tr, tc);

    if (from.isEmpty()) return false;
    if (redTurn && !from.isRed()) return false;
    if (!redTurn && !from.isBlack()) return false;
    if (!to.isEmpty() && ((redTurn && to.isRed()) || (!redTurn && to.isBlack()))) return false;
    if (fr == tr && fc == tc) return false;

    bool valid = false;
    switch (abs(from.type)) {
    case 1: valid = checkShuai(fr, fc, tr, tc, from.isRed()); break;
    case 2: valid = checkShi(fr, fc, tr, tc, from.isRed()); break;
    case 3: valid = checkXiang(fr, fc, tr, tc, from.isRed()); break;
    case 4: valid = checkMa(fr, fc, tr, tc); break;
    case 5: valid = checkChe(fr, fc, tr, tc); break;
    case 6: valid = checkPao(fr, fc, tr, tc); break;
    case 7: valid = checkBing(fr, fc, tr, tc, from.isRed()); break;
    }

    return valid;
}

// 完整验证（检测送将，用于最终确认移动）
bool isValidMove(int fr, int fc, int tr, int tc, bool redTurn) {
    return isBasicValidMove(fr, fc, tr, tc, redTurn);
}

bool checkShuai(int fr, int fc, int tr, int tc, bool red) {
    int dr = abs(tr - fr), dc = abs(tc - fc);
    // 正常移动：目标在己方九宫格内，横竖一格
    if (board.isInPalace(tr, tc, red)) {
        if ((dr == 1 && dc == 0) || (dr == 0 && dc == 1)) return true;
    }
    // 飞将：同列，中间无遮挡，目标是将/帅（可以在对方九宫格）
    if (dc == 0 && dr > 1) {
        int step = (tr > fr) ? 1 : -1;
        for (int r = fr + step; r != tr; r += step) {
            if (!board.getPiece(r, fc).isEmpty()) return false;
        }
        Piece &target = board.getPiece(tr, tc);
        if (target.type == R_SHUAI || target.type == B_JIANG) return true;
    }
    return false;
}

bool checkShi(int fr, int fc, int tr, int tc, bool red) {
    if (!board.isInPalace(tr, tc, red)) return false;
    return abs(tr - fr) == 1 && abs(tc - fc) == 1;
}

bool checkXiang(int fr, int fc, int tr, int tc, bool red) {
    if (red && tr >= 5) return false;
    if (!red && tr <= 4) return false;
    if (abs(tr - fr) != 2 || abs(tc - fc) != 2) return false;
    int er = (fr + tr) / 2, ec = (fc + tc) / 2;
    return board.getPiece(er, ec).isEmpty();
}

bool checkMa(int fr, int fc, int tr, int tc) {
    int dr = abs(tr - fr), dc = abs(tc - fc);
    if (!((dr == 2 && dc == 1) || (dr == 1 && dc == 2))) return false;
    int lr = fr, lc = fc;
    if (dr == 2) lr = fr + (tr > fr ? 1 : -1);
    else lc = fc + (tc > fc ? 1 : -1);
    return board.getPiece(lr, lc).isEmpty();
}

bool checkChe(int fr, int fc, int tr, int tc) {
    if (fr != tr && fc != tc) return false;
    if (fr == tr) {
        int step = (tc > fc) ? 1 : -1;
        for (int c = fc + step; c != tc; c += step)
            if (!board.getPiece(fr, c).isEmpty()) return false;
    }
    else {
        int step = (tr > fr) ? 1 : -1;
        for (int r = fr + step; r != tr; r += step)
            if (!board.getPiece(r, fc).isEmpty()) return false;
    }
    return true;
}

bool checkPao(int fr, int fc, int tr, int tc) {
    if (fr != tr && fc != tc) return false;
    int cnt = 0;
    if (fr == tr) {
        int step = (tc > fc) ? 1 : -1;
        for (int c = fc + step; c != tc; c += step)
            if (!board.getPiece(fr, c).isEmpty()) cnt++;
    }
    else {
        int step = (tr > fr) ? 1 : -1;
        for (int r = fr + step; r != tr; r += step)
            if (!board.getPiece(r, fc).isEmpty()) cnt++;
    }
    Piece &target = board.getPiece(tr, tc);
    if (target.isEmpty()) return cnt == 0;
    else return cnt == 1;
}

bool checkBing(int fr, int fc, int tr, int tc, bool red) {
    int dr = tr - fr, dc = abs(tc - fc);
    if (red) {
        if (!board.hasCrossedRiver(fr, red)) return dr == 1 && dc == 0;
        else return (dr == 1 && dc == 0) || (dr == 0 && dc == 1);
    }
    else {
        if (!board.hasCrossedRiver(fr, red)) return dr == -1 && dc == 0;
        else return (dr == -1 && dc == 0) || (dr == 0 && dc == 1);
    }
}

bool isInCheck(const Board &b, int kr, int kc, bool redKing) {
    for (int i = 0; i < BOARD_ROWS; i++) {
        for (int j = 0; j < BOARD_COLS; j++) {
            const Piece &p = b.getPiece(i, j);
            if (p.isEmpty()) continue;
            if ((redKing && p.isRed()) || (!redKing && p.isBlack())) continue;
            if (canAttack(b, i, j, kr, kc, p.type)) return true;
        }
    }
    return false;
}

bool canAttack(const Board &b, int fr, int fc, int tr, int tc, int type) {
    int absType = abs(type);
    bool red = type > 0;

    switch (absType) {
    case 1: {
        int dr = abs(tr - fr), dc = abs(tc - fc);
        if ((dr == 1 && dc == 0) || (dr == 0 && dc == 1)) return true;
        if (fc != tc) return false;
        int step = (tr > fr) ? 1 : -1;
        for (int r = fr + step; r != tr; r += step)
            if (!b.getPiece(r, fc).isEmpty()) return false;
        return true;
    }
    case 2: {
        return abs(tr - fr) == 1 && abs(tc - fc) == 1 && b.isInPalace(tr, tc, red);
    }
    case 3: {
        if (abs(tr - fr) != 2 || abs(tc - fc) != 2) return false;
        if (red && tr >= 5) return false;
        if (!red && tr <= 4) return false;
        return b.getPiece((fr + tr) / 2, (fc + tc) / 2).isEmpty();
    }
    case 4: {
        int dr = abs(tr - fr), dc = abs(tc - fc);
        if (!((dr == 2 && dc == 1) || (dr == 1 && dc == 2))) return false;
        int lr = fr, lc = fc;
        if (dr == 2) lr = fr + (tr > fr ? 1 : -1);
        else lc = fc + (tc > fc ? 1 : -1);
        return b.getPiece(lr, lc).isEmpty();
    }
    case 5: {
        if (fr != tr && fc != tc) return false;
        if (fr == tr) {
            int step = (tc > fc) ? 1 : -1;
            for (int c = fc + step; c != tc; c += step)
                if (!b.getPiece(fr, c).isEmpty()) return false;
        }
        else {
            int step = (tr > fr) ? 1 : -1;
            for (int r = fr + step; r != tr; r += step)
                if (!b.getPiece(r, fc).isEmpty()) return false;
        }
        return true;
    }
    case 6: {
        if (fr != tr && fc != tc) return false;
        int cnt = 0;
        if (fr == tr) {
            int step = (tc > fc) ? 1 : -1;
            for (int c = fc + step; c != tc; c += step)
                if (!b.getPiece(fr, c).isEmpty()) cnt++;
        }
        else {
            int step = (tr > fr) ? 1 : -1;
            for (int r = fr + step; r != tr; r += step)
                if (!b.getPiece(r, fc).isEmpty()) cnt++;
        }
        return cnt == 1 && !b.getPiece(tr, tc).isEmpty();
    }
    case 7: {
        int dr = tr - fr, dc = abs(tc - fc);
        if (red) {
            if (!b.hasCrossedRiver(fr, red)) return dr == 1 && dc == 0;
            else return (dr == 1 && dc == 0) || (dr == 0 && dc == 1);
        }
        else {
            if (!b.hasCrossedRiver(fr, red)) return dr == -1 && dc == 0;
            else return (dr == -1 && dc == 0) || (dr == 0 && dc == 1);
        }
    }
    }
    return false;
}

bool isCheckmate(bool redTurn) {
    int kr, kc;
    if (!board.findKing(redTurn, kr, kc)) return true;
    if (!isInCheck(board, kr, kc, redTurn)) return false;

    for (int fr = 0; fr < BOARD_ROWS; fr++) {
        for (int fc = 0; fc < BOARD_COLS; fc++) {
            Piece &p = board.getPiece(fr, fc);
            if (p.isEmpty()) continue;
            if ((redTurn && !p.isRed()) || (!redTurn && !p.isBlack())) continue;

            for (int tr = 0; tr < BOARD_ROWS; tr++) {
                for (int tc = 0; tc < BOARD_COLS; tc++) {
                    if (isValidMove(fr, fc, tr, tc, redTurn)) return false;
                }
            }
        }
    }
    return true;
}

};

// ==================== 游戏控制类 ====================

class Game {
private:
Board board;
RuleChecker rules;
bool redTurn;
bool gameOver;
string winner;
int cursorRow, cursorCol;
int fromRow, fromCol;
int state;

public:
Game() : board(), rules(board), redTurn(true), gameOver(false),
cursorRow(0), cursorCol(4), fromRow(-1), fromCol(-1),
state(STATE_SELECT_PIECE) {}

int getKey() {
    int key = _getch();
    if (key == 0 || key == 224) {
        int key2 = _getch();
        switch (key2) {
        case 72: return 'w';
        case 80: return 's';
        case 75: return 'a';
        case 77: return 'd';
        default: return 0;
        }
    }
    return key;
}

void moveCursor(int dr, int dc) {
    int nr = cursorRow + dr;
    int nc = cursorCol + dc;
    if (nr >= 0 && nr < BOARD_ROWS && nc >= 0 && nc < BOARD_COLS) {
        cursorRow = nr;
        cursorCol = nc;
    }
}

void printStatus() {
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    // 状态文字固定位置，配合局部刷新
    GotoXY(0, 32);
    if (state == STATE_SELECT_PIECE) {
        SetConsoleTextAttribute(h, redTurn ? COLOR_RED : COLOR_BLACK);
        cout << "  >>> " << (redTurn ? "红方" : "黑方") << " 选择棋子 <<<";
    }
    else {
        SetConsoleTextAttribute(h, redTurn ? COLOR_RED : COLOR_BLACK);
        cout << "  >>> " << (redTurn ? "红方" : "黑方") << " 选择目标 <<<";
    }
    SetConsoleTextAttribute(h, COLOR_WHITE);
    // 清除该行剩余文字防止残影
    cout << "                              ";
}

void run() {
    while (!gameOver) {
        bool hints[BOARD_ROWS][BOARD_COLS] = { false };
        if (state == STATE_SELECT_TARGET && fromRow >= 0) {
            for (int r = 0; r < BOARD_ROWS; r++)
                for (int c = 0; c < BOARD_COLS; c++)
                    hints[r][c] = rules.isBasicValidMove(fromRow, fromCol, r, c, redTurn);
        }

        board.print(cursorRow, cursorCol, state, fromRow, fromCol, hints);
        printStatus();

        int key = getKey();
        if (key == 0) continue;

        switch (key) {
        case 'w': case 'W': moveCursor(-1, 0); break;
        case 's': case 'S': moveCursor(1, 0); break;
        case 'a': case 'A': moveCursor(0, -1); break;
        case 'd': case 'D': moveCursor(0, 1); break;
        case 13: case 32: handleConfirm(); break;
        case 27:
            if (state == STATE_SELECT_TARGET) {
                state = STATE_SELECT_PIECE;
                fromRow = fromCol = -1;
            }
            break;
        case 'q': case 'Q': return;
        case 'r': case 'R': restart(); break;
        }
    }
}

void handleConfirm() {
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);

    if (state == STATE_SELECT_PIECE) {
        Piece &p = board.getPiece(cursorRow, cursorCol);
        if (!p.isEmpty() && ((redTurn && p.isRed()) || (!redTurn && p.isBlack()))) {
            fromRow = cursorRow;
            fromCol = cursorCol;
            state = STATE_SELECT_TARGET;
        }
    }
    else if (state == STATE_SELECT_TARGET) {
        // ==========【优化选子灵活度】选中棋子后，直接点己方棋子切换选中 ==========
        Piece &p = board.getPiece(cursorRow, cursorCol);
        if (!p.isEmpty() && ((redTurn && p.isRed()) || (!redTurn && p.isBlack()))) {
            fromRow = cursorRow;
            fromCol = cursorCol;
            return;
        }

        // 执行完整验证（含送将检测）
        if (rules.isValidMove(fromRow, fromCol, cursorRow, cursorCol, redTurn)) {
            Piece captured = board.getPiece(cursorRow, cursorCol);
            board.movePiece(fromRow, fromCol, cursorRow, cursorCol);

            if (captured.type == R_SHUAI || captured.type == B_JIANG) {
                gameOver = true;
                winner = redTurn ? "红方" : "黑方";
                bool emptyHints[BOARD_ROWS][BOARD_COLS] = { false };
                board.print(cursorRow, cursorCol, state, -1, -1, emptyHints);
                GotoXY(0, 32);
                SetConsoleTextAttribute(h, COLOR_YELLOW);
                cout << "\n  ==============================" << endl;
                cout << "    游戏结束！" << winner << "获胜！" << endl;
                cout << "  ==============================" << endl;
                SetConsoleTextAttribute(h, COLOR_WHITE);
                cout << "\n  按任意键继续...";
                _getch();
                return;
            }

            bool nextRed = !redTurn;
            if (rules.isCheckmate(nextRed)) {
                gameOver = true;
                winner = redTurn ? "红方" : "黑方";
                bool emptyHints[BOARD_ROWS][BOARD_COLS] = { false };
                board.print(cursorRow, cursorCol, state, -1, -1, emptyHints);
                GotoXY(0, 32);
                SetConsoleTextAttribute(h, COLOR_YELLOW);
                cout << "\n  ==============================" << endl;
                cout << "    将死！" << winner << "获胜！" << endl;
                cout << "  ==============================" << endl;
                SetConsoleTextAttribute(h, COLOR_WHITE);
                cout << "\n  按任意键继续...";
                _getch();
                return;
            }

            int kr, kc;
            if (board.findKing(nextRed, kr, kc)) {
                if (rules.isInCheck(board, kr, kc, nextRed)) {
                    bool emptyHints[BOARD_ROWS][BOARD_COLS] = { false };
                    board.print(cursorRow, cursorCol, state, -1, -1, emptyHints);
                    GotoXY(0, 32);
                    SetConsoleTextAttribute(h, COLOR_YELLOW);
                    cout << "\n  *** 将军！***" << endl;
                    SetConsoleTextAttribute(h, COLOR_WHITE);
                    cout << "\n  按任意键继续...";
                    _getch();
                }
            }

            redTurn = !redTurn;
            state = STATE_SELECT_PIECE;
            fromRow = fromCol = -1;
            cursorRow = redTurn ? 0 : 9;
            cursorCol = 4;
        }
        else {
            // 非法移动提示
            bool emptyHints[BOARD_ROWS][BOARD_COLS] = { false };
            board.print(cursorRow, cursorCol, state, fromRow, fromCol, emptyHints);
            GotoXY(0, 32);
            SetConsoleTextAttribute(h, COLOR_RED);
            cout << "\n  非法移动！";
            SetConsoleTextAttribute(h, COLOR_WHITE);
            cout << "                              ";
            cout << "\n  按任意键继续...";
            _getch();
        }
    }
}

void restart() {
    board.initBoard();
    redTurn = true;
    gameOver = false;
    winner = "";
    cursorRow = 0;
    cursorCol = 4;
    fromRow = fromCol = -1;
    state = STATE_SELECT_PIECE;
}

};

// ==================== 主函数 ====================

int main() {
system("chcp 936");
system("cls");
system("mode con cols=80 lines=35");

CONSOLE_CURSOR_INFO ci;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &ci);
ci.bVisible = false;
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &ci);

Game game;
while (true) {
    game.run();

    GotoXY(0, 0);
    system("cls");
    cout << "\n\n  是否重新开始？(y/n): ";
    char c = _getch();
    cout << c << endl;
    if (c != 'y' && c != 'Y') break;

    game.restart();
}
return 0;

}