c语言编写简易五子棋（附源码）

已于 2023-09-17 12:28:16 修改
阅读量2.1k 收藏 23
点赞数 11
分类专栏： c语言 文章标签： c语言 开发语言
于 2023-09-15 14:30:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scxzvcxvx/article/details/132895004
版权

本人码龄仅100多天，在上课期间学习到了三子棋，便想设计一款五子棋，供我和女朋友在自习累的时候玩，（不是炫耀hehe～）

一、整体大纲

游戏一共分为：

1、游戏目录 （包括进入、退出选项）
2、游戏内容，包括一下内容：
        2.1棋盘的初始化
        2.2棋盘的打印
        2.3玩家下棋
        2.4判断胜负

二、大概思路

        游戏分为三个部分，游戏本体的.c源文件，以及一份.h头文件，和一份供测试用的test.c文件。在整体介绍之前，先简单介绍一下game.h这个头文件。

#include <stdio.h>

#define ROW  10
#define COL  10

//初始化棋盘
void cleanboard(char board[ROW][COL],int row,int col);
//打印棋盘
void displayboard(char board[ROW][COL],int row,int col);
//玩家下棋
void playgame_player1(char board[ROW][COL],int row ,int col);
void playgame_player2(char board[ROW][COL],int row ,int col);
//判断对错
void judge(char board[ROW][COL],int*px);

1.在文件中我先定义了ROW和COL这两个量，定义这两个量的好处在于：方便后续对游戏整体规则的处理，以防去一个一个的查找修改。本次游戏选取了10行（因为太多的话，对于我这一个编程小白来说，测试就太为繁琐了.）

2.关于游戏流程的声明，分别声明了如上图所示的几个函数，包括：初始化棋盘，打印棋盘，玩家下棋（分为玩家一和玩家二），判断对错（这个函数中还包括了几个小函数，稍后指出）

接下来我将对游戏主题内容进行讲解！

3.游戏目录

void mnum()
 {
     printf("---------------------\n");
     printf("-----  1.play -------\n");
     printf("-----  2.exit -------\n");
     printf("---------------------\n");
 }

上图就是一个基本的由printf函数构成的目录，我把他写在了test.c中，没有什么好讲解的。

 int main()
{
    mnum();//游戏菜单
    printf("请输入数字：");
    int i = 0;
    scanf("%d",&i);
    do {
        switch (i)
        {
            case 1:
                game();
                break;
            case 2:
                printf("已退出\n");
                break;
            default:
                printf("输入错误，已退出！");
                break;
        }
    } while (i != 2);//当输入2时，循环结束

    return 0;
}

上图所示的是游戏的主体测试内容，首先导入游戏菜单，用scanf()函数，获取输入的数字。接下来使用do··while函数进行循环，输入1时，系统会进入game()函数，具体内容会在下面讲解。当输入2的时候，游戏会结束循环，否则就表示输入错误，进行重新输入。

4、游戏内容

4.1棋盘的初始化

void game()
 {
    char board[ROW][COL] = {0};
    //初始化棋盘
     cleanboard(board,ROW,COL);

         首先在test.c文件中，写入game()函数，其中创建一个数组，用于存放棋子。其中ROW和COL在上文已经说明，在game.h的头文件中已经被定义。

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

        接下来是棋盘的初始化，其实非常简单，用双层for函数对这个二维数组进行遍历，将数组内的每一个值赋予’ ‘（空格）。这一部分是为了下一部分，棋盘的打印做好准备。因为假如不复制，则数组中每一个值均为0，棋盘打印后打观感不好。

4.2棋盘的打印

//打印棋盘
void displayboard(char board[ROW][COL],int row,int col)
{
    int i = 0;
    int j = 0;
    for (i = 0;i<row;i++)//每一次循环，打印一个字符行一个分割行
    {
        //打印字符行
        for(j = 0;j<col;j++)
        {
            printf(" %c ", board[i][j]);//打印字符使用%c
            if(j<col-1)//防止多打一次｜
                printf("|");
        }
        printf("\n");

        //打印分割行
        if(i<row-1)//防止多打一次分割行
        {
            int k = 0;
            for ( k = 0; k < col; ++k)
            {
                printf("---");
                if(k<col-1)//防止多打一次｜
                {
                    printf("|");
                }
            }
        }
        printf("\n");
    }
}

        这里使用了2次for循环，将棋盘输出，打印到屏幕上，打印的棋盘分为两种：字符行和分割行。第一层for循环，每一次循环，打印一层字符行和一层分割行。

        字符行：首先一定要记住，打印字符使用%c，打印字符串使用%s。刚开始测试，花费了大半天不知道什么情况，一只在报错，然后看了好久，才发现我使用的是%s。呜呜呜～打印字符时采取字符两边是空格，每三个字符打印一个竖隔线（｜），if语句是防止多打一次竖隔线（｜），下面打印分割行也是同理。

        分割行：分割行中的for循环中重新定义了一个k，但是本人现在看了觉得没有必要，还是可以使用j这个变量的。首先第一个if语句是防止多打印一层分割行，第二个if语句是防止在每一行分割层多打印一个竖隔符（｜）

        棋盘打印这个函数要着重处理，因为在游戏进程中要多次调用这个函数，使用要确保万无一失再进行接下来的代码编写。

4.3玩家下棋

//玩家下棋
void playgame_player1(char board[ROW][COL],int row ,int col)
{   //防止错误输入，做循环处理
    while (1)
    {
        printf("一号玩家（#）下棋，请输入所要选择的坐标:(格式示例:1 1)");
        int i = 0;
        int j = 0;
        //玩家输入坐标
        scanf("%d %d", &i, &j);
        if(i < 1 || i > row || j < 1 || j > col)//进行非法输入判断
        {
            printf("输入非法，请重新输入！\n");
            continue;
        }
        else
        {
            if (board[i-1][j-1] == ' ')//对输入数字进行处理，-1，保持数组与外逻辑一致
            {
                board[i-1][j-1] = '#';
                break;
            }
            else
            {
                printf("此位置已有棋子，请换位置下棋！\n");
                continue;
            }
        }
    }
}

void playgame_player2(char board[ROW][COL],int row ,int col)
{
    while (1)
    {
        printf("二号玩家（*）下棋，请输入所要选择的坐标:(格式示例:1 1)");
        int i = 0;
        int j = 0;
        scanf("%d %d", &i, &j);

        if(i < 1 || i > row || j < 1 || j > col)//进行非法输入判断,||是或者的意思
        {
            printf("输入非法，请重新输入！\n");
            continue;
        }
        else
        {
            if (board[i-1][j-1] == ' ')
            {
                board[i-1][j-1] = '*';
                break;
            }
            else
            {
                printf("此位置已有棋子，请换位置下棋！\n");
                continue;
            }
        }
    }
}

        现在是第一个主要部分，涉及到玩家下棋的步骤。本人只写了两人对战，没有像别的博主一样写了人机对战的部分。在这个部分我写了两个函数，分别对应玩家一(#)和玩家二(*)。内容是一致的，使用我就挑选其中的玩家一进行讲解。

        首先，为了防止错误输出以及棋子的重复占用，在下棋阶段采取了一个死循环，当输入正确的时候break；退出循环。有一个小点需要注意，在外层游戏逻辑与内部数组的逻辑是不同的，一般人是不会觉得坐标是从0开始的，正常逻辑是从1开始，但是数组是从0开始的，所以这里有一个减去1的处理。

4.4判断胜负

        判断胜负是这个程序中最重要也是最难的一点，本人是一个编程小白，所以在这一块也是花费了很多脑筋，查阅了很多资料，最终才完成了这一部分。

        判断胜负这一部分主要分为四类：竖向判断、横向判断、左上到右下判断、右上到左下判断。我将分别探讨一下这四个部分。

void judge(char board[ROW][COL],int *px)
{
    //和棋判断
    judge_draw(board,ROW,COL,px);
    //判断列
    judge_row(board,ROW,COL,px);
    //判断行
    judge_col(board,ROW,COL,px);
    //判断对角(左上到右下）
    judge_diagonal_left(board,ROW,COL,px);
    //判读对角(右上到左下）
    judge_diagonal_right(board,ROW,COL,px);

}

        如上图所示，我把这几个判断都单一拿出来进行书写，并且整合到了一个函数中，其中还有一个刚才没有提及到的函数———关于和棋的判断，这个我们最后再讲。

4.4.1判断列

//判断列（｜）
void judge_col(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for(i = 0;i<row;i++)
    {
        for(j = 0;j<col;j++)
        {
            if(board[j][i] == board[j + 1][i] && board[j][i] != ' ' && board[j + 1][i] != ' ')
            {
                count++;
                if(count == 4)
                {
                    char arr = board[j][i];
                    if(arr == '#'){
                        printf("玩家一获胜！\n");
                        *px = 1;
                    }
                    else if(arr == '*'){
                        printf("玩家二胜利！\n");
                        *px = 2;
                    }
                }
            }
            else
                count = 0;
        }
    }
}

        如上图所示，还是采取了两层for循环的思路，单独设立了一个变量count来记录重复的个数。

        首先看到第一个if部分。当循环中出现当前board[i][j]与二维空间中的下一个元素相等时（我们知道二维数组其实不是真正的以二维空间排布的），我们将count加一，继续循环如果下一个元素与其下一个元素再相等时，count再加一。如果不想等，则将count重置为0。继续寻找。当寻找到count == 4时，表示已将找到了5个元素相等并且在同一列上，则进入if语句，创立一个字符变量，接收当前board[i][j]的值，以供后续判断是谁取得了胜利。

注：循环条件中，我已经将' '这个值去掉了，不然程序无法正常执行。

        进入到下一个if语句，上面已经提到，当count == 4时，我们进入到判断部分。其中我们新建立的字符变量如果等于第一位玩家的棋子，则打印玩家一获胜。于此同时，我们在主函数中建立了一个整形变量，以供数据的输出。如下图所示。

//玩家下棋
     while (1)//死循环构成
     {
         //一号玩家下棋
         playgame_player1(board,ROW,COL);
         //打印棋盘
         displayboard(board,ROW,COL);
         //判定胜负
         int arr1 = 0;
         judge(board,&arr1);
         if(arr1 == 1 || arr1 ==2){
             break;
         }
         else if(arr1 == 0)
         {
             printf("和棋");
             break;
         }

        我们创建的整形变量主要是用于打破循环以及和棋的输出（稍后将到）。我们通过指针的输出，改变主函数中的变量，记住形式参数不等于实际参数，它只是实际参数的一个copy版本，所以想要改变实际参数，还是要在函数的定义时传入实际变量的指针。

4.4.2判断行

//判断行（——）
void judge_row(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for(i = 0;i<row;i++)
    {
        for(j = 0;j<col;j++)
        {
            if(board[i][j] == board[i][j + 1] && board[i][j] != ' ' && board[i][j + 1] != ' ')
            //对内容进行判断
            {
                count++;
                if(count == 4)//五子棋有4个等式即可
                {
                    char arr = board[i][j];
                    if(arr == '#'){
                        printf("玩家一获胜！\n");
                        *px = 1;//指针传出数字，以供结束进程，可以是任意数字，这边方便对应所以选择了1和2.以下同理
                    }
                    else if(arr == '*'){
                        printf("玩家二胜利！\n");
                        *px = 2;
                    }
                }
            }
            else
                count = 0;
        }
    }
}

        判断行的代码与判断列的代码类似，可以根据上面判断列的逻辑来看这一段代码，我在此就不多说了。（少打一些字，偷工减料。）

4.4.3左上到右下的判断

//判断对角(左上到右下）
void judge_diagonal_left(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    for(i = 0;i<row-4;i++)
        for(j = 0;j<col-4;j++)
        {
            if(board[i][j] == board[i + 1][j + 1] && board[i][j] == board[i +2][j + 2] && 
            board[i][j] == board[i +3][j + 3] && board[i][j] == board[i + 4][j + 4] && 
            board[i][j] != ' ' && board[i + 1][j + 1] != ' ' && board[i + 2][j + 2] != ' ' && 
            board[i + 3][j + 3] != ' ' && board[i + 4][j + 4] != ' ')
            {
                char arr = board[i][j];
                if(arr == '#'){
                    printf("玩家一获胜！\n");
                    *px = 1;
                }
                else if(arr == '*'){
                    printf("玩家二胜利！\n");
                    *px = 2;}
            }
        }
}

        这一段代码可能是最难的地方，关于对角线的查找，我也是苦恼了好久，写了好多版本，但是最终还是屈服在了我的能力不高，在if语句中写死了代码，因此光if的条件写了足足四行。这段代码的主要逻辑就是一下判断一整个对角线上的五个元素，如果相等且不等于' '，我们则进行下一步的判断，在判断的逻辑上和前面的判断列的逻辑相同。这一段还有一点就在于在for循环中要控制i和j的范围，不要超过了二维数组的范围，因此我在循环的过程中将i和j都减少了4.（关于这一段的判定我也写了一个没有那么死的判断方法，逻辑看起来没有问题，但是最后没有实现该有的功能，我会在文章的最后贴出，希望各位大佬指点迷津。）

4.4.4右上到左下的判断

//判读对角(右上到左下）
void judge_diagonal_right(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    for(i = 0;i < row-4 ;i++)
        for(j = col-1;j>4;j--)
        {
            if(board[i][j] == board[i + 1][j - 1] && board[i][j] == board[i + 2][j - 2] &&
            board[i][j] == board[i +3][j - 3] && board[i][j] == board[i + 4][j - 4] && board[i][j] != ' ' &&
            board[i + 1][j - 1] != ' ' && board[i + 2][j - 2] != ' ' && board[i + 3][j - 3] != ' ' &&
            board[i + 4][j - 4] != ' ')
            {
                char arr = board[i][j];
                if(arr == '#'){
                    printf("玩家一获胜！\n");
                    *px = 1;
                }
                else if(arr == '*'){
                    printf("玩家二胜利！\n");
                    *px = 2;
                }
            }
        }
}

        和上面的代码一样，这里主要问题可能会出现在两个for循环的条件上，因为我们是从右上角判断到左下角，所以对于i我们是从0开始的，会和上面的逻辑一致。但是对于j我们是从大到小进行循环的，且是要大于4的，防止超过范围，这点上需要多多思考一下，其余的逻辑就和刚刚讲的那个没有什么不同了。

4.4.5和棋部分（补充）

//和棋判断
void judge_draw(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    *px = 0;
    for(i = 0;i < row;i++)
    {
        for(j = 0;j < col;j++)
        {
            if(board[i][j] == ' ' )
            {
                *px = 3;
                break;
            }
        }
    }
}

        这一部分为什么叫补充，因为我忘记在大纲里列出来了，第一写博客，有点不熟悉的地方，希望大家多多包涵。

        这一部分我们主要是利用在主函数中创建的变量arr1（这个名字没有什么特殊含义，可能是因为课看多了，所以就直接写上了～～）当判断开始时我们首先要給arr1赋值为0（就是*px = 0），接下来对数组进行遍历，当数组中发现了有' '存在时，我们将arr1赋值为3，结束循环。

接下来对工作主要在主函数中。

 judge(board,&arr1);
         if(arr1 == 1 || arr1 ==2){
             break;
         }
         else if(arr1 == 0)
         {
             printf("和棋");
             break;
         }

        如上图所示，假设arr1 == 0时，即在和棋判断时，对数组的遍历没有发现' '即可代表棋盘已经满了，所以此时arr1没有赋值为3，所以打印和棋，游戏结束，停止循环。

注：假如按照我的这个思路来写时，和棋的判断这个小函数一定要在判读胜负这个函数打函数的第一位，如下图所示

void judge(char board[ROW][COL],int *px)
{
    //和棋判断
    judge_draw(board,ROW,COL,px);
    //判断列
    judge_row(board,ROW,COL,px);
    //判断行
    judge_col(board,ROW,COL,px);
    //判断对角(左上到右下）
    judge_diagonal_left(board,ROW,COL,px);
    //判读对角(右上到左下）
    judge_diagonal_right(board,ROW,COL,px);

}

如果在下面会导致，某位玩家已经获胜，但是程序没有结束，因为此时在棋盘中还是会存在' '，所以先判断获胜时，系统会打印出某某玩家获胜，然后給arr1赋值为1或者2，但是到和棋判断时，我们首先会给arr1赋值为0，但是棋盘中是有' ',会给arr1重新赋值为3，所以程序不会结束。这一点可以说是我的这个整体程序的缺陷，希望在今后的学习中，可以把这个缺陷补上。

5.源码

5.1 test.c的源码

#include"game.h"
#include "game.c"
void mnum()
 {
     printf("---------------------\n");
     printf("-----  1.play -------\n");
     printf("-----  2.exit -------\n");
     printf("---------------------\n");
 }

 void game()
 {
    char board[ROW][COL] = {0};
    //初始化棋盘
     cleanboard(board,ROW,COL);

    //打印棋盘
    displayboard(board,ROW,COL);

    //玩家下棋
     while (1)//死循环构成
     {
         //一号玩家下棋
         playgame_player1(board,ROW,COL);
         //打印棋盘
         displayboard(board,ROW,COL);
         //判定胜负
         int arr1 = 0;
         judge(board,&arr1);
         if(arr1 == 1 || arr1 ==2){
             break;
         }
         else if(arr1 == 0)
         {
             printf("和棋");
             break;
         }
         //二号玩家下棋
         playgame_player2(board,ROW,COL);
         //打印棋盘
         displayboard(board,ROW,COL);
         //判断胜负
         judge(board,&arr1);
         if(arr1 == 1 || arr1 == 2){
             break;
         }
         else if(arr1 == 0)
         {
             printf("和棋");
             break;
         }
     }


 }
 int main()
{
    mnum();//游戏菜单
    printf("请输入数字：");
    int i = 0;
    scanf("%d",&i);
    do {
        switch (i)
        {
            case 1:
                game();
                break;
            case 2:
                printf("已退出\n");
                break;
            default:
                printf("输入错误，已退出！");
                break;
        }
    } while (i != 2);//当输入2时，循环结束

    return 0;
}

5.2 game.c的源码

//
// Created by 石丹阳 on 2023/9/14.
//
#include "game.h"

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

//打印棋盘
void displayboard(char board[ROW][COL],int row,int col)
{
    int i = 0;
    int j = 0;
    for (i = 0;i<row;i++)//每一次循环，打印一个字符行一个数字行
    {
        //打印字符行
        for(j = 0;j<col;j++)
        {
            printf(" %c ", board[i][j]);//打印字符使用%c
            if(j<col-1)//防止多打一次｜
                printf("|");
        }
        printf("\n");

        //打印分割行
        if(i<row-1)//防止多打一次分割行
        {
            int k = 0;
            for ( k = 0; k < col; ++k)
            {
                printf("---");
                if(k<col-1)//防止多打一次｜
                {
                    printf("|");
                }
            }
        }
        printf("\n");
    }
}

//玩家下棋
void playgame_player1(char board[ROW][COL],int row ,int col)
{   //防止错误输入，做循环处理
    while (1)
    {
        printf("一号玩家（#）下棋，请输入所要选择的坐标:(格式示例:1 1)");
        int i = 0;
        int j = 0;
        //玩家输入坐标
        scanf("%d %d", &i, &j);
        if(i < 1 || i > row || j < 1 || j > col)//进行非法输入判断
        {
            printf("输入非法，请重新输入！\n");
            continue;
        }
        else
        {
            if (board[i-1][j-1] == ' ')//对输入数字进行处理，-1，保持数组与外逻辑一致
            {
                board[i-1][j-1] = '#';
                break;
            }
            else
            {
                printf("此位置已有棋子，请换位置下棋！\n");
                continue;
            }
        }
    }
}

void playgame_player2(char board[ROW][COL],int row ,int col)
{
    while (1)
    {
        printf("二号玩家（*）下棋，请输入所要选择的坐标:(格式示例:1 1)");
        int i = 0;
        int j = 0;
        scanf("%d %d", &i, &j);

        if(i < 1 || i > row || j < 1 || j > col)//进行非法输入判断,||是或者的意思
        {
            printf("输入非法，请重新输入！\n");
            continue;
        }
        else
        {
            if (board[i-1][j-1] == ' ')
            {
                board[i-1][j-1] = '*';
                break;
            }
            else
            {
                printf("此位置已有棋子，请换位置下棋！\n");
                continue;
            }
        }
    }
}

//判断对错
//判断行（——）
void judge_row(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for(i = 0;i<row;i++)
    {
        for(j = 0;j<col;j++)
        {
            if(board[i][j] == board[i][j + 1] && board[i][j] != ' ' && board[i][j + 1] != ' ')
            //对内容进行判断
            {
                count++;
                if(count == 4)//五子棋有4个等式即可
                {
                    char arr = board[i][j];
                    if(arr == '#'){
                        printf("玩家一获胜！\n");
                        *px = 1;//指针传出数字，以供结束进程，可以是任意数字，这边方便对应所以选择了1和2.以下同理
                    }
                    else if(arr == '*'){
                        printf("玩家二胜利！\n");
                        *px = 2;
                    }
                }
            }
            else
                count = 0;
        }
    }
}

//判断列（｜）
void judge_col(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for(i = 0;i<row;i++)
    {
        for(j = 0;j<col;j++)
        {
            if(board[j][i] == board[j + 1][i] && board[j][i] != ' ' && board[j + 1][i] != ' ')
            {
                count++;
                if(count == 4)
                {
                    char arr = board[j][i];
                    if(arr == '#'){
                        printf("玩家一获胜！\n");
                        *px = 1;
                    }
                    else if(arr == '*'){
                        printf("玩家二胜利！\n");
                        *px = 2;
                    }
                }
            }
            else
                count = 0;
        }
    }
}

//判断对角(左上到右下）
void judge_diagonal_left(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    for(i = 0;i<row-4;i++)
        for(j = 0;j<col-4;j++)
        {
            if(board[i][j] == board[i + 1][j + 1] && board[i][j] == board[i +2][j + 2] &&
            board[i][j] == board[i +3][j + 3] && board[i][j] == board[i + 4][j + 4] &&
            board[i][j] != ' ' && board[i + 1][j + 1] != ' ' && board[i + 2][j + 2] != ' ' &&
            board[i + 3][j + 3] != ' ' && board[i + 4][j + 4] != ' ')
            {
                char arr = board[i][j];
                if(arr == '#'){
                    printf("玩家一获胜！\n");
                    *px = 1;
                }
                else if(arr == '*'){
                    printf("玩家二胜利！\n");
                    *px = 2;}
            }
        }
}

//判读对角(右上到左下）
void judge_diagonal_right(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    for(i = 0;i < row-4 ;i++)
        for(j = col-1;j>4;j--)
        {
            if(board[i][j] == board[i + 1][j - 1] && board[i][j] == board[i + 2][j - 2] &&
            board[i][j] == board[i +3][j - 3] && board[i][j] == board[i + 4][j - 4] && board[i][j] != ' ' &&
            board[i + 1][j - 1] != ' ' && board[i + 2][j - 2] != ' ' && board[i + 3][j - 3] != ' ' &&
            board[i + 4][j - 4] != ' ')
            {
                char arr = board[i][j];
                if(arr == '#'){
                    printf("玩家一获胜！\n");
                    *px = 1;
                }
                else if(arr == '*'){
                    printf("玩家二胜利！\n");
                    *px = 2;
                }
            }
        }
}

//和棋判断
void judge_draw(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    *px = 0;
    for(i = 0;i < row;i++)
    {
        for(j = 0;j < col;j++)
        {
            if(board[i][j] == ' ' )
            {
                *px = 3;
                break;
            }
        }
    }

}

void judge(char board[ROW][COL],int *px)
{
    //和棋判断
    judge_draw(board,ROW,COL,px);
    //判断列
    judge_row(board,ROW,COL,px);
    //判断行
    judge_col(board,ROW,COL,px);
    //判断对角(左上到右下）
    judge_diagonal_left(board,ROW,COL,px);
    //判读对角(右上到左下）
    judge_diagonal_right(board,ROW,COL,px);

}

5.3 game.h的源码

#include <stdio.h>

#define ROW  10
#define COL  10

//初始化棋盘
void cleanboard(char board[ROW][COL],int row,int col);
//打印棋盘
void displayboard(char board[ROW][COL],int row,int col);
//玩家下棋
void playgame_player1(char board[ROW][COL],int row ,int col);
void playgame_player2(char board[ROW][COL],int row ,int col);
//判断对错
void judge(char board[ROW][COL],int*px);

6.最后

        非常感谢各位能够观看我的第一篇博客，希望可以对我进行批评指正。我是一位大三的来自食品科学系的学生，因为准备跨考到计算机，所以学习了计算机的相关课程。我是因为喜欢所以才会选择这个专业，当然工资待遇也不低，我也知道这个专业很卷。路漫漫其修远。让我们一起努力。最后在此感谢各位可以阅读我的文章，感谢各位批评指正，有什么不妥的地方可以留言，我会后续进行更改～

7.附

文章中说到我关于对角线判断中，写了一个灵活性高一点的函数，但是没有成功执行，我贴在此处，希望有大佬分析解答一下。

//判断对角(左上到右下）
void judge_diagonal_left(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for(i = 0;i<row-1;i++)
        for(j = 0;j<col-1;j++)
        {
            int k = i;
            if(board[k][j] == board[k + 1][j + 1] && board[k][j] != ' ' && board[k +1][j + 1] != ' ')
            {
                count++;
                k++;
                if(count == 4)
                {
                    char arr = board[k][j];
                    if(arr == '#'){
                        printf("玩家一获胜！\n");
                        *px = 1;
                    }
                    else if(arr == '*'){
                        printf("玩家二胜利！\n");
                        *px = 2;
                    }
                }
            }
            else
                count = 0;
        }
}

//判读对角(右上到左下）
void judge_diagonal_right(char board[ROW][COL],int row,int col,int*px)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for(i = 0;i<row;i++)
        for(j = col-1;j>1;j--)
        {
            int k = i;
            if(board[k][j] == board[k + 1][j - 1] && board[k][j] != ' ' && board[k + 1][j - 1] != ' ')
            {
                count++;
                k++;
                if(count == 4)
                {
                    char arr = board[j][i];
                    if(arr == '#'){
                        printf("玩家一获胜！\n");
                        *px = 1;
                    }
                    else if(arr == '*'){
                        printf("玩家二胜利！\n");
                        *px = 2;
                    }
                }
            }
            else
                count = 0;
        }
}

shishishishi～
关注
  • 11
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
五子棋源代码完整版C++
07-29
五子棋完整代码,MFC框架，人机对战、人人对战！！！！
c语言五子棋源代码
07-25
c语言的小游戏，五子棋，下载之后任意c语言ide编译后即可运行体验或者学习~
五子棋(C语言) [实现了简单人机，人人，以及提示和复盘的功能]
最新发布
geniejiansheng的博客
05-16 492
define same_u_i same(row + dx[u] * i, col + dy[u] * i, p[row][col])//u方向i距离的点是否同色。
C语言五子棋完整源码
10-05
希望大家能学到一些什么，以供参考，这是一个C语言做的五子棋源码程序，谢谢大家支持。
【C语言 |五子棋】C语言实现五子棋
YKX0000的博客
04-16 2671
用C语言实现五子棋。
c++ 双人五子棋（可直接复制）
weixin_56274053的博客
12-26 1697
今天，我给大家带来一个五子棋的代码，希望大家喜欢。
c语言项目五子棋的实现(详解)
卜及中的博客
03-05 5969
c语言小项目-五子棋的实现
五子棋游戏代码(完整版)
akiaug的日录
12-21 1万+
Created with Raphaël 2.2.0开始棋手准备每轮更换绘制棋盘输入下棋坐标判断是否合法是否超出棋盘该坐标是否有棋子修改棋盘(下棋)判断是否修改成功判断是否获胜结束yesnoyesnoyesno Gobang类 package cn.cyh.test; import java.util.Scanner; /** * @author cyh * @create 2020/12/21 10:20 */ public class Gobang { private int[][]
五子棋小游戏 java版（代码+详细注释）
热门推荐
逗呵呵的博客
09-02 1万+
这周先来无事，再来写个五子棋小游戏。基本功能都实现了，包括人人对战、人机对战。界面布局和功能都写的还行，没做到很优秀，但也不算差。如有需要，做个java初学者的课程设计或者自己写着玩玩也都是不错的（非常简单，小白照着就能写出来）。完整代码在最后，可直接到最后粘贴，代码里面也附有详细的注释，我也会在前面对设计思路和程序的一些地方进行讲解，希望对各位有用。（如果有什么讲的不好的地方，也欢迎大家批评指正...）
C语言编写五子棋小游戏
qq_57810576的博客
07-15 255
【代码】C语言编写五子棋小游戏。
html制作好看的五子棋（源码）
xcLeigh
10-31 8367
html制作好看的五子棋,html制作五子棋对战源码,酷炫的界面效果,带AI,可本地双人一起玩,也可以单独跟AI单挑。代码内相关描述有备注,下面咋们一起来看看源码设计思路。
C语言简单五子棋源码
07-24
通过C语言实现简单的五子棋双人对战源码，代码量小，结构简单，适合C语言刚入门者学习
五子棋小游戏C语言源代码
06-11
一个简易的、用C语言写的五子棋游戏源代码，仅供参考！
五子棋小游戏（含注释）
07-13
用C++编写的五子棋小游戏，内置AI，可以单人玩。代码中含大量注释，欢迎技术参考。
基于c语言开发的五子棋源码
09-21
基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的五子棋源码 基于c语言开发的...
C语言实现简易五子棋
12-16
本文实例为大家分享了C语言实现简易五子棋的具体代码，供大家参考，具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include #include #include #define ROW 5 #define COL 5 char g_broad[ROW][COL]; void menu();...
基于c语言实现的五子棋源码
05-11
【作品名称】：基于c语言实现的五子棋源码 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
C语言简易计算器（附源码）
01-16
C语言简易计算器（附源码）
c语言小游戏之五子棋源码
03-27
C语言项目源码大全的50套源代码资源，这里是其中的c语言实现五子棋小游戏源码，大家一起学习交流哈！
用C语言编写一个五子棋游戏
07-17
您好！要用C语言编写一个五子棋游戏，可以按照以下步骤进行： 1. 创建一个棋盘：使用二维数组表示棋盘，可以选择一个合适的大小，比如15x15。 2. 初始化棋盘：将棋盘上的每个位置都设置为空。 3. 绘制棋盘：使用循环遍历棋盘数组，打印出棋盘的当前状态。 4. 处理玩家操作：使用循环，接受玩家的输入坐标，并将玩家的棋子放置在对应的位置上。 5. 检查游戏状态：每次玩家下棋后，需要检查游戏是否已经结束，比如是否有五子连线等。 6. 实现AI对手：可以选择实现一个简单的AI对手来与玩家对战，使用算法判断最优下棋位置，并自动放置棋子。 7. 循环进行玩家和AI对手的交互，直到游戏结束。 这只是一个简单的五子棋游戏框架，您可以根据需求自行扩展和优化。希望对您有帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

shishishishi～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值