// GoBang.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <graphics.h>
#include <conio.h> 
#include <cmath>
#include <Windows.h>
#include <vector>
#include <algorithm>
#include <stack>

using namespace std;

// 棋盘绘制函数声明
void GoboardDraw(int, int, int);
void DrawBoardWithoutInit(int, int, int);
void BeginDraw();

// 落点状态枚举类
enum class state
{
    none, white, black
};

enum class color
{
    B, W
};

// 玩家落子有效性确定函数声明
bool CheckPlayersGo(int& x, int& y, state goarea[15][15])
{
    bool CPGo = false;    // 声明并初始化为不落子

    // 遍历所有可能落点
    for (int i = 0; i < 15; i++)
    {
        for (int j = 0; j < 15; j++)
        {
            // 鼠标点击处距可能落点的距离
            double distance = sqrt(pow(x - (20 + i * 50), 2) + pow(y - (20 + j * 50), 2));
            if (distance < 19)
            {
                CPGo = true;
                x = 20 + i * 50;
                y = 20 + j * 50;
                if (goarea[i][j] != state::none)
                {
                    CPGo = false;
                }
                break;
            }
        }
    }

    return CPGo;
}

// 棋子类
class Go
{
public:
    // 棋子绘制函数
    void GoDraw(int, int, color, bool lastMove = false);
};

// 方向枚举
enum Direction {
    HORIZONTAL,  // 水平
    VERTICAL,    // 垂直
    DIAGONAL,    // 对角线
    ANTIDIAGONAL // 反对角线
};

// 检查边界
bool InBounds(int x, int y) {
    return x >= 0 && x < 15 && y >= 0 && y < 15;
}

// 计算指定方向上的连续棋子
int CountConsecutive(state board[15][15], int x, int y, int dx, int dy, state player) {
    int count = 0;
    int tempX = x + dx;
    int tempY = y + dy;

    while (InBounds(tempX, tempY)) {
        if (board[tempX][tempY] == player) {
            count++;
            tempX += dx;
            tempY += dy;
        }
        else {
            break;
        }
    }
    return count;
}

// 计算棋型得分
long CalculateScoreForPosition(state board[15][15], int x, int y, state player) {
    if (board[x][y] != state::none) return 0;

    // 分数权重
    const long FIVE = 10000000;   // 连五
    const long BLOCKED_FOUR = 100000;  // 冲四
    const long OPEN_FOUR = 1000000;    // 活四
    const long OPEN_THREE = 10000;     // 活三
    const long BLOCKED_THREE = 1000;   // 眠三
    const long OPEN_TWO = 100;         // 活二
    const long BLOCKED_TWO = 10;       // 眠二
    const long OPEN_ONE = 1;           // 活一

    long score = 0;

    // 检查四个方向
    int directions[4][2] = { {1,0}, {0,1}, {1,1}, {1,-1} }; // 水平、、垂直对角线、反对角线

    for (auto& dir : directions) {
        int dx = dir[0];
        int dy = dir[1];

        // 计算连续棋子
        int left = CountConsecutive(board, x, y, -dx, -dy, player);
        int right = CountConsecutive(board, x, y, dx, dy, player);
        int total = left + right + 1;  // 包括当前位置

        // 检查两端是否开放
        bool leftOpen = InBounds(x - (left + 1) * dx, y - (left + 1) * dy) &&
            board[x - (left + 1) * dx][y - (left + 1) * dy] == state::none;
        bool rightOpen = InBounds(x + (right + 1) * dx, y + (right + 1) * dy) &&
            board[x + (right + 1) * dx][y + (right + 1) * dy] == state::none;

        // 根据连续数和开放状态评分
        if (total >= 5) {
            score += FIVE;
        }
        else if (total == 4) {
            if (leftOpen && rightOpen) {
                score += OPEN_FOUR;
            }
            else if (leftOpen || rightOpen) {
                score += BLOCKED_FOUR;
            }
        }
        else if (total == 3) {
            if (leftOpen && rightOpen) {
                score += OPEN_THREE;
            }
            else if (leftOpen || rightOpen) {
                score += BLOCKED_THREE;
            }
        }
        else if (total == 2) {
            if (leftOpen && rightOpen) {
                score += OPEN_TWO;
            }
            else if (leftOpen || rightOpen) {
                score += BLOCKED_TWO;
            }
        }
        else if (total == 1) {
            if (leftOpen || rightOpen) {
                score += OPEN_ONE;
            }
        }
    }

    // 中心区域加成
    int centerX = 7, centerY = 7;
    int distToCenter = abs(x - centerX) + abs(y - centerY);
    score += (14 - distToCenter) * 10;  // 离中心越近加成越高

    return score;
}

// 自动选定落子函数声明及定义
static void AutoGo(int& AutoX, int& AutoY, state G[15][15], color cl)
{
    // 拷贝当前棋盘状态
    state goarea[15][15];
    for (int i = 0; i < 15; i++) {
        for (int j = 0; j < 15; j++) {
            goarea[i][j] = G[i][j];
        }
    }

    // 确定当前玩家和对手
    state currentPlayer = (cl == color::B) ? state::black : state::white;
    state opponent = (cl == color::B) ? state::white : state::black;

    long bestScore = -1;
    int bestX = -1, bestY = -1;

    // 遍历所有空位
    for (int i = 0; i < 15; i++) {
        for (int j = 0; j < 15; j++) {
            if (goarea[i][j] == state::none) {
                // 计算进攻得分（当前玩家）
                long attackScore = CalculateScoreForPosition(goarea, i, j, currentPlayer);

                // 计算防守得分（对手）
                long defendScore = CalculateScoreForPosition(goarea, i, j, opponent);

                // 总得分 = 进攻得分 * 1.2 + 防守得分 * 1.0
                long totalScore = attackScore * 1.2 + defendScore;

                // 如果位置更好，更新最佳位置
                if (totalScore > bestScore) {
                    bestScore = totalScore;
                    bestX = i;
                    bestY = j;
                }
            }
        }
    }

    // 确保找到有效位置
    if (bestX != -1 && bestY != -1) {
        AutoX = bestX;
        AutoY = bestY;
    }
    else {
        // 如果没有找到有效位置，选择第一个空位
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                if (goarea[i][j] == state::none) {
                    AutoX = i;
                    AutoY = j;
                    return;
                }
            }
        }
    }
}

// 判断是否五子连珠函数
bool WinCheck(state(&GoArea)[15][15], int& whowins)
{
    bool wincheck = false;
    int directions[4][2] = { {1,0}, {0,1}, {1,1}, {1,-1} }; // 水平、垂直、对角线、反对角线

    for (int i = 0; i < 15; i++)
    {
        for (int j = 0; j < 15; j++)
        {
            if (GoArea[i][j] == state::none) continue;

            state player = GoArea[i][j];

            for (auto& dir : directions) {
                int dx = dir[0];
                int dy = dir[1];

                int count = 1; // 当前位置

                // 向正方向检查
                for (int k = 1; k < 5; k++) {
                    int ni = i + k * dx;
                    int nj = j + k * dy;
                    if (ni < 0 || ni >= 15 || nj < 0 || nj >= 15) break;
                    if (GoArea[ni][nj] != player) break;
                    count++;
                }

                // 向反方向检查
                for (int k = 1; k < 5; k++) {
                    int ni = i - k * dx;
                    int nj = j - k * dy;
                    if (ni < 0 || ni >= 15 || nj < 0 || nj >= 15) break;
                    if (GoArea[ni][nj] != player) break;
                    count++;
                }

                if (count >= 5) {
                    wincheck = true;
                    whowins = (player == state::black) ? 1 : -1;
                    return wincheck;
                }
            }
        }
    }
    return wincheck;
}

// 绘制点击效果
void DrawClickEffect(int x, int y) {
    setfillcolor(YELLOW);
    solidcircle(x, y, 15);
    FlushBatchDraw();
    Sleep(100); // 短暂显示
}

// 重新开始游戏
void RestartGame(state goarea[15][15], int& Gonumber, int& lastMoveX, int& lastMoveY, stack<pair<int, int>>& moveHistory, bool& gameOver) {
    // 重置棋盘
    for (int i = 0; i < 15; i++) {
        for (int j = 0; j < 15; j++) {
            goarea[i][j] = state::none;
        }
    }
    Gonumber = 0;
    lastMoveX = -1;
    lastMoveY = -1;
    gameOver = false;
    // 清空历史记录
    while (!moveHistory.empty()) moveHistory.pop();
    cleardevice();
    DrawBoardWithoutInit(1200, 742, 0);
}

int main()
{
    BeginDraw();

    // 定义棋子数组
    Go go[225];
    // 定义落点状态数组
    state goarea[15][15] = { state::none };        // 行、列
    int Gonumber = 0;    // 棋子数量定义与初始化
    color Color = color::B;    // 棋子颜色决定数定义与初始化

    int whocheck = 0;        //

    int whichX = 0;        // 程序选择的点位x数（列数）
    int whichY = 0;        // 程序选择的点位y数（行数） 

    bool begincheckfirst = true;    // 开始确认布尔值    初始化为否
    bool begincheck = false;    // 开始确认布尔值    初始化为否
    bool entercheck = false;    // 进入棋盘布尔值    初始化为否
    bool gameOver = false;      // 游戏结束标志

    // 添加角色选择相关变量
    bool roleSelected = false;   // 角色是否已选择
    bool playerIsBlack = true;   // 玩家是否执黑（默认执黑）
    bool playerTurn = true;      // 是否玩家回合（默认玩家先手）

    // 上一手位置
    int lastMoveX = -1;
    int lastMoveY = -1;

    // 历史记录栈
    stack<pair<int, int>> moveHistory;

    // 监测鼠标状态
    while (true)
    {
        // 定义鼠标状态变量
        MOUSEMSG m;

        // 获取鼠标状态
        m = GetMouseMsg();

        // 检测到鼠标点击开始键    且开始确认值为真
        if (m.uMsg == WM_LBUTTONDOWN && begincheckfirst == true)
        {
            int xcheckbigin = m.x;
            int ycheckbigin = m.y;
            if (xcheckbigin > 50 && xcheckbigin < 250 && ycheckbigin > 270 && ycheckbigin < 320)
            {
                begincheck = true;
                begincheckfirst = false;

                // 关闭开始界面窗口
                closegraph();

                // 初始化游戏主窗口
                initgraph(1200, 742);
                BeginBatchDraw();  // 开始批量绘制
                DrawBoardWithoutInit(1200, 742, 0);
                FlushBatchDraw();  // 刷新，显示棋盘

                Sleep(500);
            }

            else if (xcheckbigin > 50 && xcheckbigin < 250 && ycheckbigin > 370 && ycheckbigin < 420)
            {
                Sleep(300);

                exit(0);
            }
        }

        // 角色选择（在棋盘界面上）
        if (m.uMsg == WM_LBUTTONDOWN && begincheck == true && !roleSelected && !gameOver)
        {
            // 执黑按钮 (850,250,1080,330)
            if (m.x >= 850 && m.x <= 1080 && m.y >= 250 && m.y <= 330)
            {
                playerIsBlack = true;
                playerTurn = true;  // 玩家先手
                roleSelected = true;

                // 更新按钮状态
                setfillcolor(GREEN);
                fillroundrect(850, 250, 1080, 330, 23, 23);
                setfillcolor(GREEN);
                fillroundrect(850, 430, 1080, 510, 23, 23);

                setbkmode(TRANSPARENT);
                settextcolor(BLACK);
                TCHAR s2[] = TEXT("隶书");
                settextstyle(50, 25, s2);
                outtextxy(915, 265, TEXT("执黑"));

                setbkmode(TRANSPARENT);
                settextcolor(BLACK);
                TCHAR s3[] = TEXT("隶书");
                settextstyle(50, 25, s3);
                outtextxy(915, 445, TEXT("执白"));
                FlushBatchDraw();
            }
            // 执白按钮 (850,430,1080,510)
            else if (m.x >= 850 && m.x <= 1080 && m.y >= 430 && m.y <= 510)
            {
                playerIsBlack = false;
                playerTurn = false;  // AI先手
                roleSelected = true;

                // 更新按钮状态
                setfillcolor(GREEN);
                fillroundrect(850, 250, 1080, 330, 23, 23);
                setfillcolor(GREEN);
                fillroundrect(850, 430, 1080, 510, 23, 23);

                setbkmode(TRANSPARENT);
                settextcolor(BLACK);
                TCHAR s2[] = TEXT("隶书");
                settextstyle(50, 25, s2);
                outtextxy(915, 265, TEXT("执黑"));

                setbkmode(TRANSPARENT);
                settextcolor(BLACK);
                TCHAR s3[] = TEXT("隶书");
                settextstyle(50, 25, s3);
                outtextxy(915, 445, TEXT("执白"));
                FlushBatchDraw();

                // 如果玩家选择执白，AI先手落子
                AutoGo(whichX, whichY, goarea, color::B); // AI执黑
                goarea[whichX][whichY] = state::black;
                go[Gonumber].GoDraw(whichX * 50 + 20, whichY * 50 + 20, color::B, true);
                Gonumber++;
                lastMoveX = whichX;
                lastMoveY = whichY;
                moveHistory.push(make_pair(whichX, whichY));
                FlushBatchDraw();

                // 检查AI是否获胜
                if (WinCheck(goarea, whocheck)) {
                    if (whocheck == 1) {
                        cout << "\a";
                        int result = MessageBox(GetHWnd(), TEXT("AI胜利! 重新开始吗？"), TEXT("游戏结束"), MB_YESNO);
                        if (result == IDYES) {
                            RestartGame(goarea, Gonumber, lastMoveX, lastMoveY, moveHistory, gameOver);
                            roleSelected = false;
                            // 重新绘制棋盘
                            DrawBoardWithoutInit(1200, 742, 0);
                            FlushBatchDraw();
                        }
                        else {
                            gameOver = true;
                        }
                    }
                }

                // 设置玩家回合
                playerTurn = true;
            }
        }

        // 重新开始按钮
        if (m.uMsg == WM_LBUTTONDOWN && begincheck == true && roleSelected &&
            m.x >= 850 && m.x <= 1080 && m.y >= 70 && m.y <= 150)
        {
            RestartGame(goarea, Gonumber, lastMoveX, lastMoveY, moveHistory, gameOver);
            roleSelected = false;  // 需要重新选择角色
            gameOver = false;
            playerTurn = true;
            // 重新绘制棋盘
            DrawBoardWithoutInit(1200, 742, 0);
            FlushBatchDraw();
            continue;
        }

        // 悔棋按钮
        if (m.uMsg == WM_LBUTTONDOWN && begincheck == true && roleSelected &&
            m.x >= 850 && m.x <= 1080 && m.y >= 610 && m.y <= 690 && Gonumber > 0 && !gameOver)
        {
            // 悔棋逻辑
            if (!moveHistory.empty()) {
                // 获取最后一步
                pair<int, int> last = moveHistory.top();
                moveHistory.pop();

                // 清除棋子
                goarea[last.first][last.second] = state::none;
                Gonumber--;

                // 更新上一手位置
                if (!moveHistory.empty()) {
                    lastMoveX = moveHistory.top().first;
                    lastMoveY = moveHistory.top().second;
                }
                else {
                    lastMoveX = -1;
                    lastMoveY = -1;
                }

                // 重新绘制棋盘
                cleardevice();
                DrawBoardWithoutInit(1200, 742, 0);

                // 重新绘制所有棋子（只标记最后一手）
                for (int i = 0; i < 15; i++) {
                    for (int j = 0; j < 15; j++) {
                        if (goarea[i][j] == state::black) {
                            bool isLast = (lastMoveX == i && lastMoveY == j);
                            go[0].GoDraw(i * 50 + 20, j * 50 + 20, color::B, isLast);
                        }
                        else if (goarea[i][j] == state::white) {
                            bool isLast = (lastMoveX == i && lastMoveY == j);
                            go[0].GoDraw(i * 50 + 20, j * 50 + 20, color::W, isLast);
                        }
                    }
                }

                FlushBatchDraw(); // 刷新批量绘制

                // 切换回合
                playerTurn = !playerTurn;
            }
        }

        // 检测到鼠标点击（游戏进行中）
        if (m.uMsg == WM_LBUTTONDOWN && begincheck == true && roleSelected && playerTurn && !gameOver)
        {
            if (entercheck == true)
            {
                int x = m.x;    // 获取x坐标
                int y = m.y;    // 获取y坐标
                int X = 0;
                int Y = 0;

                if (CheckPlayersGo(x, y, goarea))
                {
                    // 添加点击效果
                    DrawClickEffect(x, y);

                    // 根据玩家角色绘制棋子
                    if (playerIsBlack) {
                        X = (x - 20) / 50;
                        Y = (y - 20) / 50;
                        // 先清除所有棋子的红点标记
                        for (int i = 0; i < 15; i++) {
                            for (int j = 0; j < 15; j++) {
                                if (goarea[i][j] == state::black) {
                                    go[0].GoDraw(i * 50 + 20, j * 50 + 20, color::B, false);
                                }
                            }
                        }
                        go[Gonumber].GoDraw(x, y, color::B, true);
                        goarea[X][Y] = state::black;
                    }
                    else {
                        X = (x - 20) / 50;
                        Y = (y - 20) / 50;
                        // 先清除所有棋子的红点标记
                        for (int i = 0; i < 15; i++) {
                            for (int j = 0; j < 15; j++) {
                                if (goarea[i][j] == state::white) {
                                    go[0].GoDraw(i * 50 + 20, j * 50 + 20, color::W, false);
                                }
                            }
                        }
                        go[Gonumber].GoDraw(x, y, color::W, true);
                        goarea[X][Y] = state::white;
                    }
                    FlushBatchDraw();

                    // 更新上一手位置
                    lastMoveX = X;
                    lastMoveY = Y;
                    moveHistory.push(make_pair(X, Y));

                    Gonumber++;

                    // 检查玩家是否获胜
                    if (WinCheck(goarea, whocheck)) {
                        if ((playerIsBlack && whocheck == 1) || (!playerIsBlack && whocheck == -1)) {
                            cout << "\a";
                            int result = MessageBox(GetHWnd(), TEXT("玩家胜利! 重新开始吗？"), TEXT("游戏结束"), MB_YESNO);
                            if (result == IDYES) {
                                RestartGame(goarea, Gonumber, lastMoveX, lastMoveY, moveHistory, gameOver);
                                roleSelected = false;
                                // 重新绘制棋盘
                                DrawBoardWithoutInit(1200, 742, 0);
                                FlushBatchDraw();
                            }
                            else {
                                gameOver = true;
                            }
                        }
                    }

                    playerTurn = false; // 切换到AI回合
                }
            }
            entercheck = true;
        }

        // AI回合
        if (begincheck == true && roleSelected && !playerTurn && !gameOver)
        {
            // 确定AI颜色 - 修复：AI颜色与玩家相反
            color aiColor = playerIsBlack ? color::W : color::B;

            AutoGo(whichX, whichY, goarea, aiColor);
            if (aiColor == color::B)
            {
                // 先清除所有棋子的红点标记
                for (int i = 0; i < 15; i++) {
                    for (int j = 0; j < 15; j++) {
                        if (goarea[i][j] == state::black) {
                            go[0].GoDraw(i * 50 + 20, j * 50 + 20, color::B, false);
                        }
                    }
                }
                go[Gonumber].GoDraw(whichX * 50 + 20, whichY * 50 + 20, color::B, true);
                goarea[whichX][whichY] = state::black;
            }
            else
            {
                // 先清除所有棋子的红点标记
                for (int i = 0; i < 15; i++) {
                    for (int j = 0; j < 15; j++) {
                        if (goarea[i][j] == state::white) {
                            go[0].GoDraw(i * 50 + 20, j * 50 + 20, color::W, false);
                        }
                    }
                }
                go[Gonumber].GoDraw(whichX * 50 + 20, whichY * 50 + 20, color::W, true);
                goarea[whichX][whichY] = state::white;
            }
            FlushBatchDraw();

            // 更新上一手位置
            lastMoveX = whichX;
            lastMoveY = whichY;
            moveHistory.push(make_pair(whichX, whichY));

            Gonumber++;

            // 检查AI是否获胜
            if (WinCheck(goarea, whocheck)) {
                // 修复：正确判断AI胜利条件
                if ((aiColor == color::B && whocheck == 1) ||
                    (aiColor == color::W && whocheck == -1)) {
                    cout << "\a";
                    int result = MessageBox(GetHWnd(), TEXT("AI胜利! 重新开始吗？"), TEXT("游戏结束"), MB_YESNO);
                    if (result == IDYES) {
                        RestartGame(goarea, Gonumber, lastMoveX, lastMoveY, moveHistory, gameOver);
                        roleSelected = false;
                        // 重新绘制棋盘
                        DrawBoardWithoutInit(1200, 742, 0);
                        FlushBatchDraw();
                    }
                    else {
                        gameOver = true;
                    }
                }
            }

            playerTurn = true; // 切换回玩家回合
            Sleep(500); // 添加延迟使AI落子更自然
        }
    }

    return 0;
}


// 棋盘绘制函数定义 (不初始化窗口)
void DrawBoardWithoutInit(int width, int height, int kinds)
{
    setbkcolor(RGB(185, 190, 56));
    cleardevice();

    for (int i = 0; i < 15; i++)
    {
        setfillcolor(RGBtoGRAY(256));
        bar(20 + 50 * i, 20, 21 + 50 * i, 720);
        bar(20, 20 + 50 * i, 720, 21 + 50 * i);
    }
    solidcircle(170, 170, 5);
    solidcircle(370, 370, 5);
    solidcircle(570, 570, 5);
    solidcircle(570, 170, 5);
    solidcircle(170, 570, 5);

    // 重新开始按钮
    setfillcolor(GREEN);
    fillroundrect(850, 70, 1080, 150, 23, 23);

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s1[] = TEXT("隶书");
    settextstyle(50, 25, s1);

    outtextxy(915, 85, TEXT("重弈"));

    // 执黑按钮
    setfillcolor(GREEN);
    fillroundrect(850, 250, 1080, 330, 23, 23);

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s2[] = TEXT("隶书");
    settextstyle(50, 25, s2);

    outtextxy(915, 265, TEXT("执黑"));

    // 执白按钮
    setfillcolor(GREEN);
    fillroundrect(850, 430, 1080, 510, 23, 23);

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s3[] = TEXT("隶书");
    settextstyle(50, 25, s3);

    outtextxy(915, 445, TEXT("执白"));

    // 悔棋按钮
    setfillcolor(GREEN);
    fillroundrect(850, 610, 1080, 690, 23, 23);

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s4[] = TEXT("隶书");
    settextstyle(50, 25, s4);

    outtextxy(915, 625, TEXT("悔棋"));
}

void BeginDraw()
{
    initgraph(300, 500);
    setbkcolor(RGB(165, 170, 56));
    cleardevice();

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s4[] = TEXT("Snap ITC");
    settextstyle(81, 36, s4);
    outtextxy(23, 123, TEXT("Gom"));

    setbkmode(TRANSPARENT);
    settextcolor(WHITE);
    TCHAR s2[] = TEXT("Snap ITC");
    settextstyle(80, 35, s2);

    outtextxy(25, 125, TEXT("Gom"));


    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s3[] = TEXT("Snap ITC");
    settextstyle(80, 35, s3);

    outtextxy(165, 125, TEXT("oku"));
    setfillcolor(BLACK);
    solidcircle(186, 71, 18);

    setfillcolor(BLACK);
    solidcircle(136, 121, 18);
    setfillcolor(WHITE);
    solidcircle(136, 121, 16);

    setfillcolor(BLACK);
    fillroundrect(47, 267, 253, 323, 23, 23);

    setfillcolor(GREEN);
    fillroundrect(50, 270, 250, 320, 23, 23);

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s10[] = TEXT("隶书");
    settextstyle(40, 20, s10);

    outtextxy(70, 275, TEXT("开始对弈"));

    setfillcolor(BLACK);
    fillroundrect(47, 367, 253, 423, 23, 23);

    setfillcolor(GREEN);
    fillroundrect(50, 370, 250, 420, 23, 23);

    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    TCHAR s11[] = TEXT("隶书");
    settextstyle(40, 20, s11);

    outtextxy(70, 375, TEXT("拒绝对弈"));
}

// 棋子绘制函数定义
void Go::GoDraw(int x, int y, color Dcl, bool lastMove)
{
    // 黑子绘制
    if (Dcl == color::B)
    {
        setfillcolor(BLACK);
        solidcircle(x, y, 19);

        // 如果是上一手，绘制红点标记
        if (lastMove) {
            setfillcolor(RED);
            solidcircle(x, y, 5);
        }
    }

    // 白子绘制
    if (Dcl == color::W)
    {
        setfillcolor(BLACK);
        solidcircle(x, y, 19);
        setfillcolor(WHITE);
        solidcircle(x, y, 18);

        // 如果是上一手，绘制红点标记
        if (lastMove) {
            setfillcolor(RED);
            solidcircle(x, y, 5);
        }
    }
}