完善的五子棋悔棋代码

以下是基于Python的五子棋悔棋代码：

board = [[0 for i in range(15)] for j in range(15)] # 棋盘，0表示没有棋子，1表示黑子，2表示白子
history = [] # 保存棋局历史

# 悔棋函数
def undo():
    if len(history) > 0:
        x, y, player = history.pop() # 取出最后一步棋的位置和玩家
        board[x][y] = 0 # 棋盘上该位置变为空
        return True
    else:
        return False

# 落子函数
def put(x, y, player):
    if board[x][y] == 0: # 该位置没有棋子
        board[x][y] = player # 在该位置落子
        history.append((x, y, player)) # 保存历史记录
        return True
    else:
        return False

使用示例：

# 黑方在(3,3)处落子
put(3, 3, 1)

# 白方在(4,4)处落子
put(4, 4, 2)

# 黑方悔棋
undo()

注意事项：

1. 悔棋只能撤销最后一步棋，不能一次性撤销多步棋。
2. 悔棋操作应该在落子前进行，否则会影响棋盘状态。

相关问题

c语言五子棋代码加入菜单包括开始进入游戏，结束游戏，复盘，悔棋

好的，下面是一个简单的C语言五子棋代码，其中包括了开始进入游戏、结束游戏、复盘和悔棋的菜单功能。请注意，这个代码只是一个简单的示例，可以根据需要进行修改和完善。

#include <stdio.h>
#include <stdlib.h>

#define ROW 15
#define COL 15

int board[ROW][COL]; // 棋盘
int turn; // 玩家轮流下棋
int endgame; // 游戏是否结束

// 初始化棋盘
void init_board() {
    int i, j;
    for (i = 0; i < ROW; i++) {
        for (j = 0; j < COL; j++) {
            board[i][j] = 0;
        }
    }
}

// 显示棋盘
void display() {
    int i, j;
    printf("  ");
    for (i = 0; i < COL; i++) {
        printf("%c ", 'A' + i);
    }
    printf("\n");
    for (i = 0; i < ROW; i++) {
        printf("%2d", i + 1);
        for (j = 0; j < COL; j++) {
            if (board[i][j] == 0) {
                printf(" +");
            } else if (board[i][j] == 1) {
                printf(" X");
            } else if (board[i][j] == 2) {
                printf(" O");
            }
        }
        printf("\n");
    }
}

// 判断是否胜利
int win(int row, int col) {
    int i, j, k;
    int count;

    // 水平方向
    count = 1;
    for (i = col - 1; i >= 0 && board[row][i] == turn; i--) {
        count++;
    }
    for (i = col + 1; i < COL && board[row][i] == turn; i++) {
        count++;
    }
    if (count >= 5) {
        return 1;
    }

    // 垂直方向
    count = 1;
    for (i = row - 1; i >= 0 && board[i][col] == turn; i--) {
        count++;
    }
    for (i = row + 1; i < ROW && board[i][col] == turn; i++) {
        count++;
    }
    if (count >= 5) {
        return 1;
    }

    // 左上到右下方向
    count = 1;
    for (i = row - 1, j = col - 1; i >= 0 && j >= 0 && board[i][j] == turn; i--, j--) {
        count++;
    }
    for (i = row + 1, j = col + 1; i < ROW && j < COL && board[i][j] == turn; i++, j++) {
        count++;
    }
    if (count >= 5) {
        return 1;
    }

    // 右上到左下方向
    count = 1;
    for (i = row - 1, j = col + 1; i >= 0 && j < COL && board[i][j] == turn; i--, j++) {
        count++;
    }
    for (i = row + 1, j = col - 1; i < ROW && j >= 0 && board[i][j] == turn; i++, j--) {
        count++;
    }
    if (count >= 5) {
        return 1;
    }

    return 0;
}

// 下棋
void play() {
    int row, col;
    printf("请 %c 方下棋：\n", turn == 1 ? 'X' : 'O');
    while (1) {
        printf("请输入行和列（例如：3D）：");
        char input[10];
        scanf("%s", input);
        if (input[0] < '1' || input[0] > '9' ||
            input[1] < 'A' || input[1] > 'A' + COL - 1 ||
            input[2] != '\0') {
            printf("输入不合法，请重新输入！\n");
            continue;
        }
        row = input[0] - '1';
        col = input[1] - 'A';
        if (board[row][col] != 0) {
            printf("此位置已经有棋子，请重新输入！\n");
            continue;
        }
        break;
    }
    board[row][col] = turn;
    if (win(row, col)) {
        printf("%c 方胜利！\n", turn == 1 ? 'X' : 'O');
        endgame = 1;
    }
    turn = 3 - turn; // 轮换玩家
}

// 开始游戏
void start_game() {
    init_board();
    display();
    turn = 1;
    endgame = 0;
    while (!endgame) {
        play();
        display();
    }
}

// 复盘
void replay() {
    int i, j, step = 0;
    while (1) {
        printf("请输入步数（1-%d）：", ROW * COL);
        scanf("%d", &step);
        if (step < 1 || step > ROW * COL) {
            printf("输入不合法，请重新输入！\n");
            continue;
        }
        break;
    }
    init_board();
    for (i = 0; i < step; i++) {
        int row = rand() % ROW;
        int col = rand() % COL;
        while (board[row][col] != 0) {
            row = rand() % ROW;
            col = rand() % COL;
        }
        board[row][col] = i % 2 + 1;
    }
    display();
}

// 悔棋
void undo() {
    int i, j;
    for (i = ROW - 1; i >= 0; i--) {
        for (j = COL - 1; j >= 0; j--) {
            if (board[i][j] != 0) {
                board[i][j] = 0;
                display();
                return;
            }
        }
    }
}

int main() {
    int choice;
    while (1) {
        printf("五子棋游戏\n");
        printf("1. 开始游戏\n");
        printf("2. 结束游戏\n");
        printf("3. 复盘\n");
        printf("4. 悔棋\n");
        printf("请选择：");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                start_game();
                break;
            case 2:
                printf("谢谢使用！\n");
                return 0;
            case 3:
                replay();
                break;
            case 4:
                undo();
                break;
            default:
                printf("输入不合法，请重新输入！\n");
                break;
        }
    }
    return 0;
}

注意：这个代码只是一个简单的示例，可能存在一些问题。如果您需要在实际应用中使用，请自行进行修改和完善。

用VS 2017并且运用easy-x编写一个五子棋带有悔棋和认输功能的代码

好的，下面是一个简单的五子棋游戏的代码示例，主要实现了棋盘绘制、落子、悔棋和认输等功能。注意，以下代码仅供参考，你需要根据实际情况进行修改和完善。

#include <graphics.h>
#include <conio.h>
#include <stack>
using namespace std;

const int BOARD_SIZE = 15;  // 棋盘大小
const int CELL_SIZE = 40;  // 棋盘格子大小
const int BOARD_LEFT = 50; // 棋盘左上角坐标
const int BOARD_TOP = 50;

enum class ChessType { NONE, BLACK, WHITE }; // 棋子类型
enum class GameState { PLAYING, BLACK_WIN, WHITE_WIN, DRAW }; // 游戏状态

class ChessBoard {
public:
    ChessBoard() {
        init();
    }

    void init() {
        memset(board_, 0, sizeof(board_));
        current_player_ = ChessType::BLACK;
        game_state_ = GameState::PLAYING;
        undo_stack_.clear();
    }

    void draw() {
        cleardevice();
        setbkcolor(WHITE);
        setfillcolor(RGB(232, 189, 109));
        solidrectangle(BOARD_LEFT, BOARD_TOP, BOARD_LEFT + BOARD_SIZE * CELL_SIZE, BOARD_TOP + BOARD_SIZE * CELL_SIZE);
        setlinecolor(BLACK);
        for (int i = 0; i < BOARD_SIZE; ++i) {
            line(BOARD_LEFT, BOARD_TOP + i * CELL_SIZE, BOARD_LEFT + (BOARD_SIZE - 1) * CELL_SIZE, BOARD_TOP + i * CELL_SIZE);
            line(BOARD_LEFT + i * CELL_SIZE, BOARD_TOP, BOARD_LEFT + i * CELL_SIZE, BOARD_TOP + (BOARD_SIZE - 1) * CELL_SIZE);
        }
        for (int i = 0; i < BOARD_SIZE; ++i) {
            for (int j = 0; j < BOARD_SIZE; ++j) {
                int x = BOARD_LEFT + i * CELL_SIZE;
                int y = BOARD_TOP + j * CELL_SIZE;
                if (board_[i][j] == ChessType::BLACK) {
                    setfillcolor(BLACK);
                    solidcircle(x, y, CELL_SIZE / 2 - 2);
                } else if (board_[i][j] == ChessType::WHITE) {
                    setfillcolor(WHITE);
                    solidcircle(x, y, CELL_SIZE / 2 - 2);
                }
            }
        }
        settextcolor(BLACK);
        settextstyle(20, 0, _T("Consolas"));
        outtextxy(BOARD_LEFT, BOARD_TOP + BOARD_SIZE * CELL_SIZE + 10, _T("按 R 键重新开始游戏，Q 键退出游戏"));
        outtextxy(BOARD_LEFT, BOARD_TOP + BOARD_SIZE * CELL_SIZE + 40, _T("按 U 键悔棋，S 键认输"));
    }

    void putChess(int x, int y) {
        if (game_state_ != GameState::PLAYING) {
            return;
        }
        if (x < 0 || x >= BOARD_SIZE || y < 0 || y >= BOARD_SIZE) {
            return;
        }
        if (board_[x][y] != ChessType::NONE) {
            return;
        }
        board_[x][y] = current_player_;
        undo_stack_.push({x, y, current_player_});
        if (checkWin(x, y)) {
            game_state_ = (current_player_ == ChessType::BLACK) ? GameState::BLACK_WIN : GameState::WHITE_WIN;
        } else if (checkDraw()) {
            game_state_ = GameState::DRAW;
        } else {
            current_player_ = (current_player_ == ChessType::BLACK) ? ChessType::WHITE : ChessType::BLACK;
        }
    }

    bool checkWin(int x, int y) {
        int dx[4] = {1, 0, 1, 1};
        int dy[4] = {0, 1, 1, -1};
        for (int i = 0; i < 4; ++i) {
            int count = 1;
            for (int j = 1; j <= 4; ++j) {
                int nx = x + j * dx[i];
                int ny = y + j * dy[i];
                if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE || board_[nx][ny] != current_player_) {
                    break;
                }
                ++count;
            }
            for (int j = 1; j <= 4; ++j) {
                int nx = x - j * dx[i];
                int ny = y - j * dy[i];
                if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE || board_[nx][ny] != current_player_) {
                    break;
                }
                ++count;
            }
            if (count >= 5) {
                return true;
            }
        }
        return false;
    }

    bool checkDraw() {
        for (int i = 0; i < BOARD_SIZE; ++i) {
            for (int j = 0; j < BOARD_SIZE; ++j) {
                if (board_[i][j] == ChessType::NONE) {
                    return false;
                }
            }
        }
        return true;
    }

    void undo() {
        if (!undo_stack_.empty()) {
            auto last_move = undo_stack_.top();
            undo_stack_.pop();
            board_[last_move.x][last_move.y] = ChessType::NONE;
            current_player_ = last_move.player;
            game_state_ = GameState::PLAYING;
        }
    }

    void resign() {
        if (game_state_ == GameState::PLAYING) {
            game_state_ = (current_player_ == ChessType::BLACK) ? GameState::WHITE_WIN : GameState::BLACK_WIN;
        }
    }

    ChessType getCurrentPlayer() const {
        return current_player_;
    }

    GameState getGameState() const {
        return game_state_;
    }

private:
    struct Move {
        int x;
        int y;
        ChessType player;
    };

    ChessType board_[BOARD_SIZE][BOARD_SIZE]; // 棋盘数组
    ChessType current_player_; // 当前玩家
    GameState game_state_; // 游戏状态
    stack<Move> undo_stack_; // 悔棋记录
};

int main() {
    initgraph(BOARD_LEFT + BOARD_SIZE * CELL_SIZE + 200, BOARD_TOP + BOARD_SIZE * CELL_SIZE, SHOWCONSOLE);
    setbkcolor(WHITE);

    ChessBoard board;

    while (true) {
        board.draw();

        if (board.getGameState() != GameState::PLAYING) {
            TCHAR msg[100];
            if (board.getGameState() == GameState::BLACK_WIN) {
                _stprintf_s(msg, _T("黑方胜利"));
            } else if (board.getGameState() == GameState::WHITE_WIN) {
                _stprintf_s(msg, _T("白方胜利"));
            } else {
                _stprintf_s(msg, _T("平局"));
            }
            MessageBox(NULL, msg, _T("游戏结束"), MB_OK);
            board.init();
            continue;
        }

        if (board.getCurrentPlayer() == ChessType::BLACK) {
            outtextxy(BOARD_LEFT + BOARD_SIZE * CELL_SIZE + 10, BOARD_TOP, _T("黑方下棋"));
        } else {
            outtextxy(BOARD_LEFT + BOARD_SIZE * CELL_SIZE + 10, BOARD_TOP, _T("白方下棋"));
        }

        int x = -1;
        int y = -1;
        if (_kbhit()) {
            int ch = _getch();
            if (ch == 'q' || ch == 'Q') {
                break;
            } else if (ch == 'r' || ch == 'R') {
                board.init();
                continue;
            } else if (ch == 'u' || ch == 'U') {
                board.undo();
                continue;
            } else if (ch == 's' || ch == 'S') {
                board.resign();
                continue;
            } else if (ch == ' ') {
                POINT pt;
                GetCursorPos(&pt);
                ScreenToClient(GetForegroundWindow(), &pt);
                x = (pt.x - BOARD_LEFT + CELL_SIZE / 2) / CELL_SIZE;
                y = (pt.y - BOARD_TOP + CELL_SIZE / 2) / CELL_SIZE;
            }
        }

        if (x >= 0 && y >= 0) {
            board.putChess(x, y);
        }

        Sleep(10);
    }

    closegraph();

    return 0;
}

运行以上代码，可以看到一个简单的五子棋游戏界面，支持悔棋、认输等功能。