easyx做五子棋不适用鼠标

是的，您完全可以使用键盘而不使用鼠标来编写五子棋游戏。如果您使用EasyX图形库来编写五子棋游戏，可以使用以下代码来获取键盘输入。

#include <conio.h> // 用于获取键盘输入

while (true) {
    if (_kbhit()) { // 判断是否有键盘输入
        char ch = _getch(); // 获取键盘输入
        // 在这里处理键盘输入
    }
    // 在这里更新游戏界面
}

在获取到键盘输入后，您可以将其转换为相应的游戏操作，例如在棋盘上落子、悔棋、重新开始等操作。同时，您也可以使用EasyX提供的API在屏幕上显示游戏界面。

相关问题

给出easyx做五子棋的代码且不使用鼠标

好的，以下是一个使用EasyX图形库实现的五子棋游戏的代码，其中使用键盘输入来操控游戏。

#include <graphics.h>
#include <conio.h>
#include <iostream>

using namespace std;

// 棋盘大小
const int BOARD_SIZE = 15;
// 棋盘格子大小
const int GRID_SIZE = 40;
// 棋盘边缘留白大小
const int BOARD_PADDING = 20;
// 棋子半径
const int PIECE_RADIUS = 18;

// 棋盘数组，0表示无子，1表示黑子，2表示白子
int board[BOARD_SIZE][BOARD_SIZE] = {0};

// 当前下棋方，1表示黑方，2表示白方
int current_player = 1;

// 绘制棋盘
void draw_board() {
    // 绘制棋盘背景
    setfillcolor(RGB(204, 121, 63));
    solidrectangle(BOARD_PADDING, BOARD_PADDING, BOARD_PADDING + BOARD_SIZE * GRID_SIZE, BOARD_PADDING + BOARD_SIZE * GRID_SIZE);

    // 绘制棋盘网格线
    setlinecolor(BLACK);
    for (int i = 0; i < BOARD_SIZE; i++) {
        line(BOARD_PADDING + GRID_SIZE * i, BOARD_PADDING, BOARD_PADDING + GRID_SIZE * i, BOARD_PADDING + GRID_SIZE * (BOARD_SIZE - 1));
        line(BOARD_PADDING, BOARD_PADDING + GRID_SIZE * i, BOARD_PADDING + GRID_SIZE * (BOARD_SIZE - 1), BOARD_PADDING + GRID_SIZE * i);
    }

    // 绘制星位
    setfillcolor(BLACK);
    solidcircle(BOARD_PADDING + 3 * GRID_SIZE, BOARD_PADDING + 3 * GRID_SIZE, 5);
    solidcircle(BOARD_PADDING + 11 * GRID_SIZE, BOARD_PADDING + 3 * GRID_SIZE, 5);
    solidcircle(BOARD_PADDING + 7 * GRID_SIZE, BOARD_PADDING + 7 * GRID_SIZE, 5);
    solidcircle(BOARD_PADDING + 3 * GRID_SIZE, BOARD_PADDING + 11 * GRID_SIZE, 5);
    solidcircle(BOARD_PADDING + 11 * GRID_SIZE, BOARD_PADDING + 11 * GRID_SIZE, 5);
}

// 绘制棋子
void draw_piece(int x, int y, int player) {
    setfillcolor(player == 1 ? BLACK : WHITE);
    solidcircle(BOARD_PADDING + x * GRID_SIZE, BOARD_PADDING + y * GRID_SIZE, PIECE_RADIUS);
}

// 判断当前下棋方是否胜利
bool check_win() {
    int dx[4] = {1, 0, 1, 1};
    int dy[4] = {0, 1, 1, -1};
    for (int i = 0; i < BOARD_SIZE; i++) {
        for (int j = 0; j < BOARD_SIZE; j++) {
            if (board[i][j] == current_player) {
                for (int k = 0; k < 4; k++) {
                    int count = 1;
                    int x = i + dx[k];
                    int y = j + dy[k];
                    while (x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == current_player) {
                        count++;
                        x += dx[k];
                        y += dy[k];
                    }
                    if (count >= 5) return true;
                }
            }
        }
    }
    return false;
}

int main() {
    // 初始化窗口
    initgraph(BOARD_PADDING * 2 + BOARD_SIZE * GRID_SIZE, BOARD_PADDING * 2 + BOARD_SIZE * GRID_SIZE);
    setbkcolor(RGB(204, 121, 63));
    cleardevice();
    settextcolor(BLACK);

    // 绘制棋盘
    draw_board();

    // 循环等待键盘输入
    while (true) {
        if (_kbhit()) {
            char ch = _getch();
            switch (ch) {
                case 'a': { // 左移
                    if (board[0][0] != 0) break;
                    if (board[BOARD_SIZE - 1][0] == 0) break;
                    for (int i = 0; i < BOARD_SIZE; i++) {
                        for (int j = 0; j < BOARD_SIZE - 1; j++) {
                            board[i][j] = board[i][j+1];
                        }
                    }
                    for (int i = 0; i < BOARD_SIZE; i++) {
                        board[i][BOARD_SIZE - 1] = 0;
                    }
                    break;
                }
                case 'd': { // 右移
                    if (board[0][0] != 0) break;
                    if (board[BOARD_SIZE - 1][BOARD_SIZE - 1] == 0) break;
                    for (int i = 0; i < BOARD_SIZE; i++) {
                        for (int j = BOARD_SIZE - 1; j > 0; j--) {
                            board[i][j] = board[i][j-1];
                        }
                    }
                    for (int i = 0; i < BOARD_SIZE; i++) {
                        board[i][0] = 0;
                    }
                    break;
                }
                case 'w': { // 上移
                    if (board[0][0] != 0) break;
                    if (board[0][BOARD_SIZE - 1] == 0) break;
                    for (int i = 0; i < BOARD_SIZE - 1; i++) {
                        for (int j = 0; j < BOARD_SIZE; j++) {
                            board[i][j] = board[i+1][j];
                        }
                    }
                    for (int j = 0; j < BOARD_SIZE; j++) {
                        board[BOARD_SIZE - 1][j] = 0;
                    }
                    break;
                }
                case 's': { // 下移
                    if (board[0][0] != 0) break;
                    if (board[BOARD_SIZE - 1][BOARD_SIZE - 1] == 0) break;
                    for (int i = BOARD_SIZE - 1; i > 0; i--) {
                        for (int j = 0; j < BOARD_SIZE; j++) {
                            board[i][j] = board[i-1][j];
                        }
                    }
                    for (int j = 0; j < BOARD_SIZE; j++) {
                        board[0][j] = 0;
                    }
                    break;
                }
                case ' ': { // 落子
                    if (board[0][0] != 0) break;
                    int x = (mousex() - BOARD_PADDING + GRID_SIZE / 2) / GRID_SIZE;
                    int y = (mousey() - BOARD_PADDING + GRID_SIZE / 2) / GRID_SIZE;
                    if (x < 0 || x >= BOARD_SIZE || y < 0 || y >= BOARD_SIZE) break;
                    if (board[x][y] != 0) break;
                    board[x][y] = current_player;
                    draw_piece(x, y, current_player);
                    if (check_win()) {
                        outtextxy(BOARD_PADDING, BOARD_PADDING + BOARD_SIZE * GRID_SIZE + 10, current_player == 1 ? "Black wins!" : "White wins!");
                        _getch();
                        closegraph();
                        return 0;
                    }
                    current_player = 3 - current_player;
                    break;
                }
            }
        }
    }

    closegraph();
    return 0;
}

需要注意的是，由于EasyX没有提供键盘输入事件，我们需要使用`_kbhit()`和`_getch()`函数来获取键盘输入。在游戏中，按下a、d、w、s键可以实现棋盘的左移、右移、上移、下移操作；按下空格键可以在当前下棋方的位置落子。同时，我们也需要实现检查当前下棋方是否胜利的函数`check_win()`。

用easyx实现五子棋

使用EasyX实现五子棋的步骤如下：

1. 导入EasyX库，并创建画布

首先需要导入EasyX库，并创建一个画布用于绘图。

2. 绘制游戏界面

使用EasyX提供的绘图函数，绘制出五子棋的游戏界面，包括棋盘、落子点等。

3. 实现游戏逻辑

通过监听鼠标事件，可以获取到玩家在棋盘上的点击位置。根据点击位置，判断落子的有效性，并在合适的位置绘制相应的棋子。

4. 判断胜负条件

每次玩家落子后，需要判断是否出现五子连珠的情况。可以编写一个判断函数，根据当前的棋盘状态判断是否有一方获胜。

5. 实现人机对战

通过编写一个简单的AI算法来实现人机对战的功能。AI可以根据当前的棋盘状态，计算出最优的下棋位置，并在合适的位置绘制相应的棋子。

6. 完善游戏功能

可以在游戏界面上添加一些按钮，如重新开始、悔棋等功能，以增强游戏体验。

7. 优化界面

通过调整画笔的样式、颜色等参数，可以让游戏界面更加美观。

总结：使用EasyX实现五子棋，主要包括创建画布、绘制游戏界面、实现游戏逻辑、判断胜负条件、实现人机对战、完善游戏功能以及优化界面等步骤。通过编写的代码和EasyX库提供的方法，可以实现一个完整的五子棋游戏，并提供简单的人机对战功能。