三子棋优化实现双人对战

最新推荐文章于 2024-07-25 17:57:45 发布
最新推荐文章于 2024-07-25 17:57:45 发布
阅读量75 收藏 1
点赞数
分类专栏： 游戏 文章标签： c++ c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71063955/article/details/127827017
版权

直接上代码

game.h文件

#define  _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
#include<string.h>
#define ROW 3
#define COL 3

//初始化棋盘
void init_board(char arr[ROW][COL], int, int);

//打印棋盘
void print_board(char board[ROW][COL], int, int);

//玩家下棋
void person_move(char board[ROW][COL], int, int);
void person2_move(char board[ROW][COL], int, int);





//电脑下棋
void computer_move(char board[ROW][COL], int row, int col);


//判断棋盘是否下满
int is_full(char board[ROW][COL], int row, int col);

//检查是否有一方获胜
char check_win(char board[ROW][COL], int row, int col);

test.c文件

  

#define  _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

#define ROW 3
#define COL 3

void menu() {
    printf("****************************\n");
    printf("*****   0 退出游戏    ******\n");
    printf("*****   1 进入游戏    ******\n");
    printf("****************************\n");
}


void model_menu() {
    printf("***************************\n");
    printf("** a 人机模式 b 双人模式 **\n");
    printf("***************************\n");

}

void difficulty_menu() {
    printf("***************************\n");
    printf("** e 简单模式 d 困难模式 **\n");
    printf("***************************\n");
}


//电脑简单下棋
void computer_move_easy(char board[ROW][COL], int row, int col) {
    int i = 0, j = 0;
    printf("电脑走：\n");
    while (1) {
        i = rand() % row;
        j = rand() % col;
        if (board[i][j] == ' ') {
            board[i][j] = '#';
            break;
        }
    }
}

//检查电脑是否一线两子 如果有直接赢
int computer_will_win(char board[ROW][COL], int row, int col) {
    int i = 0;
    int j = 0;
    int p_win = 0;//标志是否直接赢
    if (0 == p_win)
    {
        //判断电脑横行上是否会赢
        for (i = 0; i < row; i++)
        {
            if (board[i][0] == board[i][1] && board[i][1] == '#' && board[i][2] == ' ')
            {
                board[i][2] = '#';
                p_win = 1;
                break;
            }
            if (board[i][0] == board[i][2] && board[i][0] == '#' && board[i][1] == ' ')
            {
                board[i][1] = '#';
                p_win = 1;
                break;
            }

            if (board[i][1] == board[i][2] && board[i][1] == '#' && board[i][0] == ' ')
            {
                board[i][0] = '#';
                p_win = 1;
                break;
            }
        }
        if (p_win != 0)
            return p_win;
        //判断电脑列上是否有机会赢
        for (j = 0; j < col; j++)
        {
            if (board[0][j] == board[1][j] && board[1][j] == '#' && board[2][j] == ' ')
            {
                board[2][j] = '#';
                p_win = 1;
                break;
            }

            if (board[0][j] == board[2][j] && board[2][j] == '#' && board[1][j] == ' ')
            {
                board[1][j] = '#';
                p_win = 1;
                break;
            }
            if (board[1][j] == board[2][j] && board[2][j] == '#' && board[0][j] == ' ')
            {
                board[0][j] = '#';
                p_win = 1;
                break;
            }
        }
        if (p_win != 0)
            return p_win;
    }
    //判断电脑在对角线上是否会赢
    if (0 == p_win)
    {
        if (board[0][0] == board[1][1] && board[1][1] == '#' && board[2][2] == ' ')
        {
            board[2][2] = '#';
            p_win = 1;
            return p_win;

        }

        if (board[0][0] == board[2][2] && board[2][2] == '#' && board[1][1] == ' ')
        {
            board[1][1] = '#';
            p_win = 1;
            return p_win;

        }

        if (board[1][1] == board[2][2] && board[1][1] == '#' && board[0][0] == ' ')
        {
            board[0][0] = '#';
            p_win = 1;
            return p_win;

        }

        if (board[0][2] == board[1][1] && board[0][2] == '#' && board[2][0] == ' ')
        {
            board[2][0] = '#';
            p_win = 1;
            return p_win;

        }

        if (board[0][2] == board[2][0] && board[2][0] == '#' && board[1][1] == ' ')
        {
            board[1][1] = '#';
            p_win = 1;
            return p_win;

        }
        if (board[1][1] == board[2][0] && board[2][0] == '#' && board[0][2] == ' ')
        {
            board[0][2] = '#';
            p_win = 1;
            return p_win;

        }

    }

    return p_win;//p_win==0 说明没有下棋 需再次下棋
}

//检测玩家是否能一线两子  如果有就拦截
int people_will_win(char board[ROW][COL], int row, int col) {
    int i = 0;
    int j = 0;
    int k = 0;
    while (0 == k)
    {
        //判断玩家在横行上是否会赢
        for (i = 0; i < row; i++)
        {
            if (board[i][0] == board[i][1] && board[i][1] == '*' && board[i][2] == ' ')
            {
                board[i][2] = '#';
                k = 1;
                break;
            }

            if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
            {
                board[i][1] = '#';
                k = 1;
                break;
            }

            if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
            {
                board[i][0] = '#';
                k = 1;
                break;
            }
        }
        if (k != 0)
            break;

        //判断玩家在竖列上是否会赢
        for (j = 0; j < col; j++)
        {
            if (board[0][j] == board[1][j] && board[1][j] == '*' && board[2][j] == ' ')
            {
                board[2][j] = '#';
                k = 1;
                break;
            }

            if (board[0][j] == board[2][j] && board[2][j] == '*' && board[1][j] == ' ')
            {
                board[1][j] = '#';
                k = 1;
                break;
            }

            if (board[1][j] == board[2][j] && board[2][j] == '*' && board[0][j] == ' ')
            {
                board[0][j] = '#';
                k = 1;
                break;
            }
        }
        break;
    }

    //判断玩家在对角线上是否会赢
    while (0 == k)
    {
        if (board[0][0] == board[1][1] && board[1][1] == '*' && board[2][2] == ' ')
        {
            board[2][2] = '#';
            k = 1;
            break;
        }

        if (board[0][0] == board[2][2] && board[2][2] == '*' && board[1][1] == ' ')
        {
            board[1][1] = '#';
            k = 1;
            break;
        }

        if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
        {
            board[0][0] = '#';
            k = 1;
            break;
        }

        if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
        {
            board[2][0] = '#';
            k = 1;
            break;
        }

        if (board[0][2] == board[2][0] && board[2][0] == '*' && board[1][1] == ' ')
        {
            board[1][1] = '#';
            k = 1;
            break;
        }

        if (board[1][1] == board[2][0] && board[2][0] == '*' && board[0][2] == ' ')
        {
            board[0][2] = '#';
            k = 1;
            break;
        }
        break;
    }
    return k;//返回值如果是1那么已经对玩家进行了阻拦，如果是0则无需阻拦。
}

//电脑下棋优化版
void computer_move_diff(char board[ROW][COL], int row, int col) {
    int i = 0, j = 0;
    int p;
    printf("电脑走：\n");

    //电脑先检测自己这一次落棋后自己是否能赢
    p = computer_will_win(board, row, col);
    if (p == 1) {//电脑已经下过棋
        return;
    }
    //检查玩家是否会赢 会赢直接堵截
    p = people_will_win(board, row, col);
    if (p == 1) {//电脑对玩家进行了堵截不需要再下
        return;
    }
    //运行到这说明也没有赢 也没有堵截 随机下棋
    while (1) {
        i = rand() % row;
        j = rand() % col;
        if (board[i][j] == ' ') {
            board[i][j] = '#';
            break;
        }
    }

}




//双人对战游戏
void play_game_pvp() {
    char key;//接收输赢结果
    //定义棋盘
    char  board[ROW][COL];
    //初始化棋盘
    init_board(board, ROW, COL);
    //打印棋盘
    print_board(board, ROW, COL);

    while (1)
    {
        printf("请p1下棋：(输入坐标)>");
        person_move(board, ROW, COL);//玩家1下棋
        print_board(board, ROW, COL);//打印棋盘    
        key = check_win(board, ROW, COL);//判输赢平局
        //打印输赢结果
        if (key == '*')
        {
            printf("恭喜p1赢啦\n");
            break;
        }
        if (key == '#')
        {
            printf("恭喜p2赢了\n");
            break;
        }
        if (key == '$')
        {
            printf("平局了！\n");
            break;
        }
        printf("请p2下棋：(输入坐标)>");
        person2_move(board, ROW, COL);//玩家2下棋
        print_board(board, ROW, COL);//打印棋盘
        key = check_win(board, ROW, COL);//判输赢平局
        //打印输赢结果
        if (key == '*')
        {
            printf("恭喜你获得胜利啦\n");
            break;
        }
        if (key == '#')
        {
            printf("p2赢了！\n");
            break;
        }
        if (key == '$')
        {
            printf("你们打平局了！\n");
            break;
        }

    }
}

//人机对战游戏
void playgame_pvc(char* diff) {

    char key;//接收输赢结果

    //定义棋盘
    char  board[ROW][COL];

    //初始化棋盘
    init_board(board, ROW, COL);

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

    while (1)
    {
        printf("请下棋：(输入坐标)>");
        person_move(board, ROW, COL);//玩家下棋
        print_board(board, ROW, COL);//打印棋盘    
        key = check_win(board, ROW, COL);//判输赢平局
        //打印输赢结果
        if (key == '*')
        {
            printf("恭喜你赢啦\n");
            break;
        }
        if (key == '#')
        {
            printf("电脑居然赢了\n");
            break;
        }
        if (key == '$')
        {
            printf("平局了！\n");
            break;
        }

        if (*diff == 'e') {
            computer_move_easy(board, ROW, COL);//简单版电脑下棋
        }
        else if (*diff == 'd') {
            computer_move_diff(board, ROW, COL);
        }

        print_board(board, ROW, COL);//打印棋盘
        key = check_win(board, ROW, COL);//判输赢平局
        //打印输赢结果
        if (key == '*')
        {
            printf("恭喜你获得胜利啦\n");
            break;
        }
        if (key == '#')
        {
            printf("很可惜，电脑赢了\n");
            break;
        }
        if (key == '$')
        {
            printf("你们打平局了！\n");
            break;
        }
    }

}

void playgame() {
    char model;//接收用户选择的模式
    char difficulty;//接收难度系数
    char ch;//接收数据 用于清空缓存区
    model_menu();
    printf("请你选择模式 >");
    while ((ch = getchar()) != '\n' && ch != EOF);//清空缓存区  
    scanf("%c", &model);

    if (model == 'a') {
        difficulty_menu();
        printf("请选择难度等级：");
        while ((ch = getchar()) != '\n' && ch != EOF);//清空缓存区 

        scanf("%c", &difficulty);
        if (difficulty == 'd') {
            printf("困难模式开始...\n");
            playgame_pvc(&difficulty);
        }
        else if (difficulty == 'e') {
            printf("简单模式开始...\n");
            playgame_pvc(&difficulty);
        }
    }
    else if (model == 'b') {
        printf("人人对战\n");
        play_game_pvp();
    }
}


int main() {
    srand((unsigned int)time(NULL));
    int input = 0;
    do
    {
        menu();
        printf("请输入 >");
        scanf("%d", &input);
        switch (input) {
        case 1:
            playgame();
            break;
        case 0:
            printf("游戏退出...\n");
            break;
        default:
            printf("请输入正确的格式\n");
        }

    } while (input);

    return 0;
}

game.c文件

#define  _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

//初始化棋盘
void init_board(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 print_board(char board[ROW][COL], int row, int col) {
    int i = 0;
    for (i = 0; i < row; i++) {
        //打印数据
        for (int j = 0; j < col; j++) {
            if (j < col - 1)
                printf(" %c |", board[i][j]);
            else
                printf(" %c\n", board[i][j]);
        }
        //打印分隔符
        if (i < row - 1) {
            for (int j = 0; j < row; j++) {
                if (j < row - 1)
                    printf("---|");
                else
                    printf("---\n");
            }
        }
    }
}

//玩家下棋
void person_move(char board[ROW][COL], int row, int col) {
    int i = 0, j = 0;

    while (1) {
        scanf("%d %d", &i, &j);
        if (board[i - 1][j - 1] == ' ') {
            board[i - 1][j - 1] = '*';
            break;
        }
        else {
            printf("此位置已被下过，请重新落棋:");
        }
    }
}

//玩家2下棋
void person2_move(char board[ROW][COL], int row, int col) {
    int i = 0, j = 0;

    while (1) {
        scanf("%d %d", &i, &j);
        if (board[i - 1][j - 1] == ' ') {
            board[i - 1][j - 1] = '#';
            break;
        }
        else {
            printf("此位置已被下过，请重新落棋:");
        }
    }
}

//电脑下棋
void computer_move(char board[ROW][COL], int row, int col) {
    int i = 0, j = 0;
    printf("电脑走：\n");
    while (1) {
        i = rand() % row;
        j = rand() % col;
        if (board[i][j] == ' ') {
            board[i][j] = '#';
            break;
        }
    }
}


//判断棋盘是否下满
int is_full(char board[ROW][COL], int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (board[i][j] == ' ')
                //只要有位置为空就说明还没满
                return 0;
        }
    }
    //遍历全部都下满，则棋盘满了
    return 1;
}

//检查是否有一方获胜
char check_win(char board[ROW][COL], int row, int col)
{
    int i;
    //判断横向是否有一样的
    for (i = 0; i < row; i++)
    {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && (board[i][1] != ' '))
            return board[i][1];
    }
    //判断竖向是否有一样的
    for (i = 0; i < col; i++)
    {
        if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
            return board[1][i];
    }
    //判断对角线是否有一样的
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
        return board[1][1];
    else if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
        return board[1][1];
    //如果没人赢 检查棋盘是否满 也就是平局
    else if (is_full(board, row, col))
        return '$';
    //以上情况都没有则分不出输赢
    return 0;
}

技术IT桐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
四子棋智能下棋C语言实现
03-15
四子棋是一种简单而有趣的双人对弈游戏，玩家通过在棋盘上交替放置棋子，尝试连成四颗棋子的直线以取得胜利。在这个项目中，我们使用C语言来实现一个四子棋的智能下棋系统，这涉及到计算机算法、游戏规则的编程以及...
基于EasyX实现的三子棋游戏
12-24
本项目“基于EasyX实现的三子棋游戏”采用C语言编写，利用EasyX图形库来创建用户界面，为玩家提供一个互动的三子棋对战平台。 EasyX是一个简洁的C++图形库，它简化了Windows环境下的图形绘制工作，使得开发者无需...
C语言实现简易三子棋，支持双人对战，电脑可拦截
chfens的博客
11-08 4390
在学习二维数组后我们加以应用能写出三子棋这样一个小游戏。具体实现并不复杂。 基本思路： 游戏首先打印菜单，由我们选择单人游戏，双人游戏或退出游戏。 三子棋需要一个棋盘，我们可以通过循环打印来构造一个简单的3x3棋盘。 我们需要一个函数在每次下棋子后都打印一次来表示目前的棋盘，于是创建一个二维数组接收棋子后方可遍历打印。我们用 * 和 # 代表两种棋子。 游戏过程中玩家输入下标下棋后电脑下，直到决出胜负或平局。 直接看代码。 我们在写程序的时候要将函数模块化，不把所有函数都堆在一个源文件里。我们新建一个主
三子棋（双人对决+人机对战）
越努力越幸运
11-13 776
三子棋（双人+人机）
五子棋双人对战的实现
清风不拂面的博客
09-19 819
完成了界面，实现双人对战就很简单了。 1、定义公共变量和结构变量 Public Structure FivePos Dim x As Integer Dim y As Integer Dim color As Integer End Structure Public fpGoPos(225) As FivePos '记录下子顺序和位置 Public intGoType(224) As Integer '记录下子分布 Public intFirstGo As Integer '谁先手 Public bLimi
C语言实现三维五子棋（双人对战版）
Jia ming 的日常学习笔记
09-01 2304
问题难点 棋盘如何显示？ 胜负如何判断？ 程序特点 运用结构体数组的知识，结构体内保存字符型二维数组。 结构体数组表示了棋盘厚度，字符型二维数组表示当前棋盘状态。 胜负评判系统分为当前平面棋盘检查与竖直方向检查。 程序不足 没有禁手限制，存在不公平 仅是双人对战版本，没有AI系统 C语言代码#include<stdio.h> #include<Windows.h> #include<time.h>
C语言实现三子棋plus版本(困难人机电脑不会输，支持双人对战)
qq_45875349的博客
04-28 2814
目录一、功能描述二、游戏部分功能介绍三、代码实现1. main()代码2.游戏菜单代码3.playgame()代码3.模式菜单和难度菜单4.初始化棋盘5.打印棋盘6.玩家下棋7.简单人机下棋8.困难人机下棋8.1 电脑检测自己这次落棋后是否能赢8.2 电脑检测是否要堵玩家的棋8.3 困难人机主函数9.判断输赢9.1 判断是否棋盘满9.2 判断输、赢、平局10.双人游戏四、游戏页面以及结果演示1.人机模式1.1 简单人机1.2 困难人机2.双人模式五、全部代码 一、功能描述 该版本可以选择双人游戏和人机对战，
三子棋小游戏 C语言 （双人大战/人机大战）
m0_71927557的博客
07-02 166
运行代码，选择1或者0，选择1开始玩游戏输入你想下的坐标随后，输入你朋友想下的坐标…………………………………………几轮大战后，分出胜负结果有玩家1赢，玩家2赢，平局运行代码，选择1或者0，选择1开始玩游戏输入你想下的坐标随后，电脑自动下一个位置…………………………………………几轮大战后，分出胜负结果有玩家赢，电脑赢，平局。
三子棋小游戏
Jmayday
11-20 308
一、井字双人对战游戏（3子棋游戏） 分析 1.棋盘模拟。        因为棋盘上的交叉点正好是3行3列，因此用一个3行3列的二维数组即可。数据初始值为0，表示未有妻子落下；值为1表示落下的是1好选手棋子，之位2表示的是2号选手的棋子。 2.是否连成一条线检测。       对刚落下的妻子检查所在的行是否都是同一选手的棋子；同样再检测所有的列是否都是同一选手的棋；同样的方法再检测对角线和反
基于SpringBoot+MyBatis 五子棋双人对战
热门推荐
chenbaifan的博客
08-26 2万+
客户端主动向服务器发起请求,返回一个响应,如果客户端不主动发起请求,服务器不能主动联系客户端,在这里,我们需要服务器主动给客户端发消息,就要用到"消息推送"同 afterConnectionClosed 一样逻辑,异常关闭的情况, 获取用户的信息, 然后设置在线状态为不在线, 然后删除匹配队列中的用户。根据这三个等级,分配不同的队列,要搞一个专门的线程,不停地扫描这个匹配队列,匹配的玩家凑成了一对,就把他们取出来,放到一个房间中。...
三子棋 java_三子棋 - 暖暖要坚持 - 博客园
weixin_39639174的博客
02-20 132
java老师布置的作业有个高大上的名字叫bingo游戏，了解了才知道是所谓的三子棋游戏，这个游戏花费的时间不长，也没有发表，现在才有时间整理下，自己感觉写的很烂，有种感觉几乎是把各种可能都列了出来，请指正。(对AI不是很熟悉，按自己的理解在人机对战中写的)下面是代码，分成了两个类 一个是棋盘类，一个数主类：package 三子棋;import java.util.Scanner;public cl...
六子棋C++,用C++实现双人对战六子棋
02-02
在本文中，我们将深入探讨如何使用C++编程语言来实现一个双人对战的六子棋游戏。六子棋是一种简单而有趣的策略游戏，通常在一块棋盘上进行，两个玩家轮流放置棋子，目标是首先形成连续的六个棋子线（横向、纵向或对...
Sanziqi.rar_sanziqi_三子棋
09-22
【Sanziqi.rar_sanziqi_三子棋】是一个基于Java编程语言开发的小游戏，它实现了经典的三子棋玩法。三子棋，又称井字游戏，是一种简单的双人对弈游戏，目标是在3x3或更大棋盘上，先连成一行、一列或对角线的三个棋子...
uni-app实现的三子棋对战小游戏，打开即用
12-21
【uni-app实现的三子棋对战小游戏】是一款基于uni-app框架开发的轻量级在线对战游戏，专为移动设备和多平台发布而设计。它具有简洁的用户界面和直观的游戏逻辑，允许两个玩家通过触摸屏幕进行实时对战。这款小游戏的...
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 413
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3486
【代码】背单词工具(C++)
C：图案打印
2401_85010100的博客
07-23 996
空心正方形，空心三角形，X形，沙漏图案打印
C++| STL之迭代器和vector
最新发布
qq_40306845的博客
07-25 351
C++STL迭代器是介绍和使用，以及vector工具的理解和使用。
C#实现的五子棋游戏与网络对战设计
项目旨在实现一个具备人机对战和双人联网对战功能的五子棋游戏。课程设计报告详细阐述了游戏的开发过程和技术实现。 一．设计要求与思路： 1. 游戏设计要求注重用户体验，提供直观易用的界面，允许玩家进行游戏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

技术IT桐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值