用C语言实现三子棋

最新推荐文章于 2023-04-16 19:03:21 发布
最新推荐文章于 2023-04-16 19:03:21 发布
阅读量390 收藏 1
点赞数
分类专栏： C语言 文章标签： 函数 c语言 框架 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyroben/article/details/53290157
版权

将三子棋的代码分为三部分：头文件存放game.h （主要用来声明各种函数，以便调用） ；源文件分别存放game.c（主要用来存放各种函数实现的代码）以及test.c（主要用来实现整个游戏代码框架）。

game.h代码：

#ifndef __GAME_H__
#define __GAME_H__
#define ROWS 3
#define COLS  3
void  Init_chessboard(int board[ROWS][COLS], int rows, int cols);   //初始化棋盘
void  Play_move_chess(int board[ROWS][COLS], int rows, int cols); //玩家走棋
void  Computer_move_chess(int board[ROWS][COLS], int rows, int cols); //电脑自动走棋
int   Computer_think_move_chess(int board[ROWS][COLS], int rows, int cols); 
//电脑在有两个连线时候能赢走棋
void  Computer_more_think_move_chess(int board[ROWS][COLS], int rows, int cols);
//电脑能够堵玩家棋子
void  Display_chessboard(int board[ROWS][COLS], int rows, int cols);  //更新棋盘
int   Check_win(int board[ROWS][COLS], int rows, int cols);     //判断输赢
#endif //__GAME_H__

game.c

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
void  Init_chessboard(int board[ROWS][COLS], int rows, int cols)//初始化棋盘
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board[i][j] = ' ';
        }
    }
    /*memset(board, ' ', sizeof(char)*rows*cols);*/
    for (i = 0; i < rows; i++)
    {
        if (0 == i)
        {
            printf("_____________\n");
        }
        printf("|");
        for (j = 0; j < cols; j++)
        {

            printf(" %c |", board[i][j]);

        }
        printf("\n");
        printf("|___|___|___|\n");
    }
}

void  Play_move_chess(int board[ROWS][COLS], int rows, int cols) //玩家走棋
{
    int x = 0;
    int y = 0;
    while (1)
    {
        printf("请输入坐标：");
        scanf("%d%d", &x, &y);
        x--;   //因为数组的下标从零开始,所以让它输入的下标减去1
        y--;
        if ((x >= 0) && (x <= rows - 1) && (y >= 0) && (y <= cols - 1) && (board[x][y] == ' '))  //保证输入的坐标不越界且没被占用
        {
            board[x][y] = 0;
            break;
        }
        else
        {
            printf("您的输入有误,请重新输入.\n");
        }
    }
}




void  Computer_move_chess(int board[ROWS][COLS], int rows, int cols) //电脑走棋
{
    int x = 0;
    int y = 0;
    srand((unsigned int)time(NULL));
    while (1)
    {
        x = rand() % 3;
        y = rand() % 3;
        if (board[x][y] == ' ')
        {
            board[x][y] = 1;
            break;
        }
    }
}


void  Display_chessboard(int board[ROWS][COLS], int rows, int cols)  //更新棋盘
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        if (0 == i)
        {
            printf("_____________\n");
        }
        printf("|");
        for (j = 0; j < cols; j++)
        {
            if (board[i][j] == ' ')
            {
                printf(" %c |", board[i][j]);
            }
            else
            {
                printf(" %d |", board[i][j]);
            }

        }
        printf("\n");
        printf("|___|___|___|\n");
    }
}

int   Check_win(int board[ROWS][COLS], int rows, int cols)  //判断输赢
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        if ((board[i][0] == board[i][1]) && (board[i][1] == board[i][2]))  //每一行相等
        {
            if (0 == board[i][0])
            {
                return 0;
            }
            if (1 == board[i][0])
            {
                return 1;
            }
        }
    }
    for (j = 0; j < cols; j++)
    {
        if ((board[0][j] == board[1][j]) && (board[1][j] == board[2][j]))  //每一列相等
        {
            if (0 == board[0][j])
            {
                return 0;
            }
            if (1 == board[0][j])
            {
                return 1;
            }
        }
    }
    if ((board[0][0] == board[1][1]) && (board[1][1] == board[2][2]))  //主对角线一样
    {
        if (0 == board[1][1])
        {
            return 0;
        }
        if (1 == board[1][1])
        {
            return 1;
        }
    }
    if ((board[0][2] == board[1][1]) && (board[1][1] == board[2][0]))
    {
        if (0 == board[1][1])
        {
            return 0;
        }
        if (1 == board[1][1])
        {
            return 1;
        }
    }
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            if (board[i][j] == ' ')
            {
                return -1;
            }
        }
    }
    return 3;
}


int Computer_think_move_chess(int board[ROWS][COLS], int rows, int cols) 
//电脑在有两个连线时候走棋能赢
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        if ((board[i][0] + board[i][1] + board[i][2]) == (2+' '))  //每一行有两个元素相等
        {
            for (j = 0; j < cols; j++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = 1;
                    return 1;
                }
            }
        }
    }
    for (j = 0; j < cols; j++)
    {
        if (board[0][j] + board[1][j]  + board[2][j] == (2 + ' '))  //每一列相等
        {
            for (i = 0; i < cols; i++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = 1;
                    return 1;
                }
            }
        }
    }
     if (board[0][0] + board[1][1] + board[2][2]==(2+' '))  //主对角线一样
    {
         for (i = 0; i < rows; i++)
         {
             if (board[i][i] == ' ')
             {
                 { 
                     board[i][i] = 1;
                    return 1;
                 }
             }
         }
    }
    else if (board[0][2] + board[1][1] +  board[2][0]==(2+' '))
    {
        if (board[0][2] == ' ')
            { 
                board[0][2] = 1;
                return 1;
            }
       if (board[1][1] == ' ')
            {
                board[1][1] = 1;
                return 1; 
            }
       if (board[2][0]==' ')
            { 
                board[2][0] = 1;
                return 1; 
            }
    }
    else
    {
                return 0;
    }
}


void  Computer_more_think_move_chess(int board[ROWS][COLS], int rows, int cols)  //电脑能够堵玩家棋子
{
    int i = 0;
    int j = 0;
    for (i = 0; i < rows; i++)
    {
        if ((board[i][0] + board[i][1] + board[i][2]) == (0 + ' '))  //每一行有两个元素相等
        {
            for (j = 0; j < cols; j++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = 1;
                    return;
                }
            }
        }
    }
    for (j = 0; j < cols; j++)
    {
        if (board[0][j] + board[1][j] + board[2][j] == (0 + ' '))  //每一列相等
        {
            for (i = 0; i < cols; i++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = 1;
                    return;
                }
            }
        }
    }
    if (board[0][0] + board[1][1] + board[2][2] == (0 + ' '))  //主对角线一样
    {
        for (i = 0; i < rows; i++)
        {
            if (board[i][i] == ' ')
            {
                {
                    board[i][i] = 1;
                    return;
                }
            }
        }
    }
    else if (board[0][2] + board[1][1] + board[2][0] == (0 + ' '))
    {
        if (board[0][2] == ' ')
        {
            {
                board[0][2] = 1;
                return;
            }
        }
        if (board[1][1] == ' ')
        {
            {
                board[1][1] = 1;
                return;
            }
        }
        if (board[2][0] == ' ')
        {
            {
                board[2][0] = 1;
                return;
            }
        }
    }
    else
    {
        srand((unsigned int)time(NULL));
        while (1)
        {
            i = rand() % 3;
            j = rand() % 3;
            if (board[i][j] == ' ')
            {
                board[i][j] = 1;
                return;
            }
        }
    }
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "game.h"
void menu()   //打印菜单
{
    printf("☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
    printf("☆☆☆    1.PLAY    ☆☆☆\n");
    printf("☆☆☆    0.EXIT    ☆☆☆\n");
    printf("☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
}
enum Option
{
    EXIT,
    PLAY
};
void game()
{
    int k = 0;
    int execut = 0;
    int board[ROWS][COLS];
    printf("☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
    printf("☆☆☆    0.简单    ☆☆☆\n");
    printf("☆☆☆    1.中等    ☆☆☆\n");
    printf("☆☆☆    2.困难    ☆☆☆\n");
    printf("☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
    printf("请选择游戏模式：\n");
    while (1)
    {
        scanf("%d", &k);
        if ((k != 0) && (k != 1)&&(k != 2))
        {
            printf("输入错误,请重新输入.");
        }
        else
        {
            break;
        }
    }
    int ret = 0;
    Init_chessboard(board, ROWS, COLS);   //初始化棋盘
    while (1)
    {
        Play_move_chess(board, ROWS, COLS); //玩家走棋 
        Display_chessboard(board, ROWS, COLS);  //更新棋盘
        ret = Check_win(board, ROWS, COLS);   //判断输赢
        if (0 == ret)
        {
            printf("恭喜您赢了.\n");
            break;
        }
        ret = Check_win(board, ROWS, COLS);  //判断棋盘是否走满
        if (3 == ret)
        {
            printf("棋逢对手.\n");
            break;
        }
        switch(k)
        {
            case 0:
            Computer_move_chess(board, ROWS, COLS); //电脑自动走棋
            break;
            case 1:
            Computer_more_think_move_chess(board, ROWS, COLS);
            break;
            case 2:
            execut=Computer_think_move_chess(board, ROWS, COLS);
            if (0 == execut)
            Computer_more_think_move_chess(board, ROWS, COLS);
            break;
        }
        printf("电脑走之后的棋盘：\n");
        Display_chessboard(board, ROWS, COLS);  //更新棋盘
        Check_win(board, ROWS, COLS);   //判断输赢
        ret = Check_win(board, ROWS, COLS);
        if (1 == ret)
        {
            printf("很遗憾,您输了.\n");
            break;
        }
    }
}
int main()
{
    int input;
    do   //do...whlie循环保证至少打印菜单一次
    {
        menu();
        printf("请选择：");
        scanf("%d", &input);
        switch (input)
        {
        case PLAY:
            game();
            break;
        case EXIT:
            break;
        default:
            printf("您的输入有误,请重新输入.\n");
            break;
        }
    } while (input);
    return 0;
}

游戏运行情况：

这里写图片描述
这里写图片描述
这里写图片描述

sky_Mata
关注
专栏目录
基于51单片机的井字棋游戏
04-13
这是一个基于51单片机的井字棋游戏，里面包含程序，PCB,原理图，初学者完全可以自己做出来
小游戏 井字棋源代码
11-06
随便 #include <iostream> #include <string> using namespace std; typedef char chess[10]; typedef int temparr[10]; chess arr; temparr brr; int number,suc,n3,c3,n2,c2,n1,c1; void inarrdata(chess a) { a[1]='1';a[2]='2';a[3]='3'; a[4]='4';a[5]='5';a[6]='6'; a[7]='7';a[8]='8';a[9]='9'; }
C语言小程序三子棋框架设计
OddSmurfs的博客
06-24 525
基于模块化的设计思想，想要设计一个三子棋游戏，可以用不同的文件存放不同的代码，通过函数的调用，以体现C语言的面向过程特点。 将程序的源码用于三个文件存放，分别为game.h、game.c和test.c game.h：用于存放函数的声明，根据头文件的格式采取以下方式书写，保证其只调用一次。 而其中的声明部分用于对实现相应功能函数的声明，当然也可以用define定义一些标识符常量，在...
c语言编程实现简单三子棋游戏
ChaseRaod的博客
12-28 4021
分别创建test.c   game.c 两个源文件，以及game.h头文件   1. game.h中用于函数定义，如下：    #ifndef __GAME_H__ #define __GMME_H__ #define ROWS 3 #define COLS 3 void init_board(char board[ROWS][COLS], int rows,int cols);//初
C语言编写三子棋完整代码（分三个文件）
Tianzez的博客
10-21 1225
1.game.h 头文件#ifndef __GAME_H__ #define __GAME_H__#include <stdio.h> #include <string.h> #include <windows.h> #include <time.h>#define ROW 3 #define COL 3void InitBoard(char arr[ROW][COL], int row
用C语言实现三字棋程序(可简易扩展成五字棋等）
AngelDg的博客
08-17 736
三字棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。 这个小游戏相信在座的各位大佬们，在自己小时候免不了与自己的小伙伴么比试一二，再退一步说没玩过，总是看到别人玩过！ 思维过程： 初始化棋盘 展示棋盘 玩家下棋 判断输赢 电脑下棋 判断输赢（如果输赢未判断出来，则循环执行步骤3、4、5、6，直...
用C语言实现三子棋小游戏
08-08
三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现和棋的情况。 1...
C语言实现三子棋
08-25
1. 数组的应用：在C语言实现三子棋中，使用数组来存储棋盘的信息和棋子的信息。数组的声明和初始化是实现三子棋的基础。 2. 棋盘的初始化：在C语言实现三子棋中，需要初始化棋盘，将棋盘的每个元素设置为"+"，表示...
用C语言实现三子棋小游戏(详解）
最新发布
07-30
三子棋代码的全过程
C语言实现三子棋程序
08-19
在本文中，我们将详细介绍如何使用C语言实现三子棋程序，包括游戏的实现思路、代码实现细节等。 游戏思路 三子棋是一种简单的棋盘游戏，游戏的规则是：两人轮流落子，先将三个棋子排成一行的玩家获胜。为了实现这...
九宫棋源码
02-23
九宫棋源码 九宫棋源码 九宫棋源码 九宫棋源码 九宫棋源码 九宫棋源码
C语言版三子棋
02-02
完整的源代码文件，可以进行选择谁先走，电脑会自动拦截你，让你赢的不那么轻松，如果电脑先走，玩家胜利的概率为零，电脑不会出错。
C语言"黑框框"下不忍直视的三子棋实现
ssopp24的博客
10-12 3604
今天发一个界面丑到爆,无比Low的三子棋程序 同样，win32 无图形界面 输入坐标进行交互， X代表玩家下子，0代表电脑下子（rand()函数随机产生合法坐标落子）,率先连成三子则胜利。棋盘满未连成三子则平局。 程序比较简单直接发源码.三个块,game.h代表程序所需头文件、宏定义、函数声明，test.c代表程序游戏逻辑，game.c代表程序定义函数实现.
详解！C语言编程实现小游戏“三子棋”
wss_yb的博客
10-22 716
今天我们来编程实现一个充满童趣的小游戏“三子棋” 先来说一下三子棋的规则： 三子棋又叫九宫棋、圈圈叉叉、一条龙等。 将正方形对角线连起来，或相对两边依次摆上三个双方棋子， 总之只要将自己的三个棋子走成一条线， 对方就算输了。 不用再过多解释了，相信大家一定都玩过！ 那么，该如何用编程的方式实现它呢？ 首先，我们创建项目后，要建立三个文件 分别是头文件game.h,用来存储我们在编程中所自定义函...
三子棋的设计与实现
qq_44760072的博客
01-27 315
三子棋 三子棋，也叫井字棋，作为我们日常生活中的小游戏，拿来在电脑上用C语言实现比较简单，也可以作为锻炼编程能力的一个小测验.三子棋代码如下 #define _CRT_SECURE_NO_WARNINGS 0 #include<stdio.h> #include<string.h> #include<stdlib.h> #include<time.h&gt...
基于STM32单片机的三子棋（井字棋）思路分享
2301_76746056的博客
04-16 1372
基于stm32的三子棋，使用双色led矩阵进行显示，4*4矩阵键盘进行输入，主程序用到状态机思想
三子棋C语言实现（多种模式任你选）
IT_10的博客
10-17 643
头文件部分//game.h//'X':人的棋子 //'0'：电脑的棋子#ifndef __GAME_H__ #define __GAME_H__#define _CRT_SECURE_NO_WARNINGS 1#define ROWS 3 #define COLS 3enum OP { EXIT, PLAY };enum FIRST { FIRST_PLAYER=1,
三子棋实现（简单版）
qq_45075338的博客
07-02 136
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<time.h> #define ROW 3 #define COLUMN 3 //判断是否棋盘满了 int FULL(char chess_board[ROW][COLUMN]){ for (int i...
c语言简单实现三子棋（五子棋）
Zhang_1218的博客
07-17 1168
c语言简单实现三子棋（五子棋） 此版本三子棋，我将其命名为三子棋1.0，其特点在于玩家无法赢取电脑，最大可能是和电脑平局，否则就是电脑赢 若想让玩家取胜，也可以。只需将代码中的函数game（）里面玩家的走动放在电脑前面即可，即让玩家先手移动。 话不多说，直接上代码: 1.三子棋： #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _GAME_
C语言实现三子棋游戏详解及代码示例
本文详细介绍了如何使用C语言实现一个简易版的三子棋游戏。首先，了解多文件编程的重要性，因为大型项目通常会将代码划分为多个文件，以提高代码组织性和可维护性。游戏的核心是三子棋规则，玩家与电脑交替在3x3的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值