路过的人就当没看到

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

// 注意：Dev-C++ 必须用这个方式链接 ws2_32 库
#define _WIN32_WINNT 0x0501

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;  // 选择目标状态

// 网络通信结构体（发送落子数据）
struct MoveData {
    int fromRow, fromCol;
    int toRow, toCol;
};

// ==================== 棋子类 ====================
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 {
        system("cls");
        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]退出\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 Network {
private:
    SOCKET s;
    SOCKET clientSock;
    bool isServer;
    WSADATA wsaData;

public:
    Network() : s(INVALID_SOCKET), clientSock(INVALID_SOCKET), isServer(false) {}

    ~Network() {
        closesocket(clientSock);
        closesocket(s);
        WSACleanup();
    }

    bool init() {
        return WSAStartup(MAKEWORD(2, 2), &wsaData) == 0;
    }

    bool startServer() {
        isServer = true;
        s = socket(AF_INET, SOCK_STREAM, 0);
        if (s == INVALID_SOCKET) return false;

        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(8888);
        addr.sin_addr.s_addr = INADDR_ANY;

        if (bind(s, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) return false;
        listen(s, 1);

        system("cls");
        cout << "=== 服务端已启动 ===" << endl;
        cout << "等待客户端连接..." << endl;
        clientSock = accept(s, NULL, NULL);
        return clientSock != INVALID_SOCKET;
    }

    bool connectClient(const char* ip) {
        isServer = false;
        s = socket(AF_INET, SOCK_STREAM, 0);
        if (s == INVALID_SOCKET) return false;

        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(8888);
        addr.sin_addr.S_un.S_addr = inet_addr(ip);

        system("cls");
        cout << "正在连接服务端：" << ip << endl;
        if (connect(s, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
            cout << "连接失败！" << endl;
            return false;
        }
        clientSock = s;
        cout << "连接成功！" << endl;
        Sleep(1000);
        return true;
    }

    void sendMove(MoveData data) {
        send(clientSock, (char*)&data, sizeof(data), 0);
    }

    MoveData recvMove() {
        MoveData data;
        recv(clientSock, (char*)&data, sizeof(data), 0);
        return data;
    }

    bool isMyTurn(bool currentRedTurn) const {
        return (isServer && currentRedTurn) || (!isServer && !currentRedTurn);
    }
};

// ==================== 游戏控制类 ====================
class Game {
private:
    Board board;
    RuleChecker rules;
    Network net;
    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) {}

    bool initNetwork() {
        if (!net.init()) return false;
        system("cls");
        cout << "1. 服务端(红方)" << endl;
        cout << "2. 客户端(黑方)" << endl;
        cout << "请选择模式：";
        int choice;
        cin >> choice;

        if (choice == 1) return net.startServer();
        else {
            char ip[20];
            cout << "输入服务端IP：";
            cin >> ip;
            return net.connectClient(ip);
        }
    }
    
    int getKey() {
        if (!net.isMyTurn(redTurn)) return 0;
        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);
        if (!net.isMyTurn(redTurn)) {
            SetConsoleTextAttribute(h, COLOR_YELLOW);
            cout << "  >>> 等待对方走棋 <<<" << endl;
            SetConsoleTextAttribute(h, COLOR_WHITE);
            return;
        }

        if (state == STATE_SELECT_PIECE) {
            SetConsoleTextAttribute(h, redTurn ? COLOR_RED : COLOR_BLACK);
            cout << "  >>> " << (redTurn ? "红方" : "黑方") << " 选择棋子 <<<" << endl;
        } else {
            SetConsoleTextAttribute(h, redTurn ? COLOR_RED : COLOR_BLACK);
            cout << "  >>> " << (redTurn ? "红方" : "黑方") << " 选择目标 <<<" << endl;
        }
        SetConsoleTextAttribute(h, COLOR_WHITE);
    }
    
    void run() {
        if (!initNetwork()) return;

        while (!gameOver) {
            bool hints[BOARD_ROWS][BOARD_COLS] = {false};
            if (state == STATE_SELECT_TARGET && fromRow >= 0 && net.isMyTurn(redTurn)) {
                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();

            if (!net.isMyTurn(redTurn)) {
                MoveData data = net.recvMove();
                board.movePiece(data.fromRow, data.fromCol, data.toRow, data.toCol);
                redTurn = !redTurn;
                state = STATE_SELECT_PIECE;
                fromRow = fromCol = -1;
                checkGameEnd();
                continue;
            }
            
            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;
            }
        }
    }

    void checkGameEnd() {
        int kr, kc;
        bool nextRed = !redTurn;
        if (board.findKing(nextRed, kr, kc) && rules.isInCheck(board, kr, kc, nextRed)) {
            if (rules.isCheckmate(nextRed)) {
                gameOver = true;
                winner = redTurn ? "红方" : "黑方";
                bool emptyHints[BOARD_ROWS][BOARD_COLS] = {false};
                board.print(cursorRow, cursorCol, state, -1, -1, emptyHints);
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), COLOR_YELLOW);
                cout << "\n  ==============================" << endl;
                cout << "    将死！" << winner << "获胜！" << endl;
                cout << "  ==============================" << endl;
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), COLOR_WHITE);
                cout << "\n  按任意键退出...";
                _getch();
            }
        }
    }
    
    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)) {
                MoveData data;
                data.fromRow = fromRow;
                data.fromCol = fromCol;
                data.toRow = cursorRow;
                data.toCol = cursorCol;
                net.sendMove(data);

                board.movePiece(fromRow, fromCol, cursorRow, cursorCol);
                
                redTurn = !redTurn;
                state = STATE_SELECT_PIECE;
                fromRow = fromCol = -1;
                checkGameEnd();
            } else {
                bool emptyHints[BOARD_ROWS][BOARD_COLS] = {false};
                board.print(cursorRow, cursorCol, state, fromRow, fromCol, emptyHints);
                SetConsoleTextAttribute(h, COLOR_RED);
                cout << "\n  非法移动！" << endl;
                SetConsoleTextAttribute(h, COLOR_WHITE);
                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;
    game.run();
    return 0;
}