【C语言】对＜进阶版三子棋＞的完善和改进

news2024/11/14 20:11:51

这篇文章主要是对前面三子棋游戏的完善和改进。

文章目录

目录

1.将棋子*和#，改为1和0； 

2.电脑下棋显示坐标 

 3.可以选择电脑先手或玩家先手

 4.在退出游戏时显示游戏信息

 5.完善后的游戏效果

二、完整程序代码

1.game.h

2.test.c

 3.game.c

总结

前言

http://t.csdn.cn/PcROJ 在这篇文章里面，我们将进阶版三子棋实现了，但游戏效果和游戏体验不是很好，这里将它改进一下。

一、完善程序效果

1.将棋子*和#，改为1和0； 

 将原来程序中的*#替换掉，使棋子更方便确认； 

2.电脑下棋显示坐标 

有随机下时坐标和判断下时坐标： 只需要在给数组赋值后，打印一下坐标就可以啦！

 3.可以选择电脑先手或玩家先手

 这里在调用过菜单函数之后，再使用一个函数，用Switch  case 来进行选择，外面是一个do  while 循环防止程序中断；

 最后在game（）函数中，用if else 来进行一个判断，选择1是玩家先手，再后面电脑走；如果是其他的就是电脑先手。

 

 4.在退出游戏时显示游戏信息

 在test（）函数结束后，显示游戏信息。

 5.完善后的游戏效果

 

二、完整程序代码

1.game.h

 

#define ROW 3//行
#define COL 3//列

#include<stdio.h>
#include<stdlib.h>//头文件
#include<time.h>

int a, b, c, d;//结束时打印盘数的变量

void Initializ(char arr[ROW][COL], int row, int col);//初始化
void disprint(char arr[ROW][COL], int row, int col);//打印
void Playermove(char arr[ROW][COL], int row, int col);//玩家移动
void Computermove(char arr[ROW][COL], int row, int col);//电脑移动
char Judge_win(char arr[ROW][COL], int row, int col);//判断胜负
int Judge_com(char arr[ROW][COL], int row, int col, int z);//电脑判断自己能否赢
int Judge_player(char arr[ROW][COL], int row, int col, int z);//电脑判断玩家是否要赢，进行拦截

2.test.c

 

#define _CRT_SECURE_NO_WARNINGS 1

#include"game.h"

void menu()
{
    printf("------------------------------------------------------\n");
    printf("----------1.开始游戏--------0.退出游戏----------------\n");
    printf("------------------------------------------------------\n");

}

void C_Dcome()
{
    printf("------------------------------------------------------\n");
    printf("----------1.玩家先手--------2.电脑先手----------------\n");
    printf("------------------------------------------------------\n");
}
void game()
{
    
    int shind = 0;  
    int hand = 0;
    do {
        C_Dcome();
        printf("请选择：>");
        scanf("%d", &shind);
        switch (shind)
        {
        case 1:
            hand = 1;
            shind = 0;
            break;
        case 2:
            hand = 2;
            shind = 0;
            break;
        default:
            printf("输入错误\n");
            break;
        }
    } while (shind);
    int ret = 0;
    char arr[ROW][COL] = { 0 };//创建一个数组
    Initializ(arr, ROW, COL);//对数组进行初始化
    disprint(arr, ROW, COL);//打印棋盘
   
    while (1)
    {

        if (hand == 1)
        {
            Playermove(arr, ROW, COL);//玩家下棋
        }
        else
        {
            Computermove(arr, ROW, COL);//电脑下棋
        }
        disprint(arr, ROW, COL);//打印棋盘
        ret = Judge_win(arr, ROW, COL);
        if (ret != 'C')
        {
            break;
        }


        if (hand == 1)
        {
            Computermove(arr, ROW, COL);//电脑下棋
        }
        else
        {
            Playermove(arr, ROW, COL);//玩家下棋
        }
        disprint(arr, ROW, COL);//打印棋盘
        ret = Judge_win(arr, ROW, COL);
        if (ret != 'C')
        {
            break;
        }
    }
    if (ret == '1')
    {
        printf("玩家胜利！再来一盘吧！\n");
        a++;
    }
    else if (ret == '0')
    {
        printf("哈哈哈 电脑胜利啦！再去练练吧！\n");
        b++;
    }
    else if (ret == 'Q')
    {
        printf("平局\n");
        c++;
    }
   
}
void test()
{
    int input = 0;
    do
    {
        menu();
        printf("请选择：>");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            game();
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("输入错误\n");
            break;
        }
    } while (input);
}
int main()
{
    test();  
    printf("一共玩了%d盘\n", d = a + b + c);
    printf("其中:\n");
    printf("玩家胜利:%d盘\n", a);
    printf("电脑胜利:%d盘\n", b);
    printf("平局:%d盘\n", c);
    return 0;
}

 3.game.c

  

#define _CRT_SECURE_NO_WARNINGS 1

#include"game.h"

void Initializ(char arr[ROW][COL], int row, int col)//初始化数组
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            arr[i][j] = ' ';
        }
    }
}
void disprint(char arr[ROW][COL], int row, int col)//打印棋盘
{
    int i = 0;
    int j = 0;
    printf("------------");
    printf("\n");
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            printf(" %c ", arr[i][j]);

            printf("|");
        }
        printf("\n");
        if (i < row - 1)
        {
            int s = 0;
            for (s = 0; s < col; s++)
            {
                printf("---");

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

    printf("------------\n");

}
int is_full(char arr[ROW][COL], int row, int col)//判断是否平局
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        int j = 0;
        for (j = 0; j < col; j++)
        {
            if (arr[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    return 1;
}

void Playermove(char arr[ROW][COL], int row, int col)//玩家下棋
{

    int x = 0;
    int y = 0;
    int d = 0;
    printf("请玩家下棋:>");
    while (1)
    {
        scanf_s("%d%d", &x, &y);

        if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
        {
            if (arr[x - 1][y - 1] == ' ')
            {
                arr[x - 1][y - 1] = '1';
                break;
            }
            else
            {
                printf("输入错误，请重新输入：>");
            }
        }
        else
        {
            printf("输入错误，请重新输入：>");
        }
    }

}
void Computermove(char arr[ROW][COL], int row, int col)//电脑下棋
{
    int x = 0;
    int y = 0;
    int z = 0;
    printf("电脑下棋:>");  
    z = Judge_com(arr, ROW, COL, z);//电脑判断自己能否赢
    while (z == 0)
    {
        x = rand() % ROW;
        y = rand() % COL;
        if (arr[x][y] == ' ')
        {
            printf("%d %d\n", x + 1 , y + 1);
            arr[x][y] = '0';          
            break;
        }
    }
}
char Judge_win(char arr[ROW][COL], int row, int col)//判断胜负
{
    int i = 0;
    //判断3行
    for (i = 0; i < row; i++)
    {
        if (arr[i][0] == arr[i][1] && arr[i][1] == arr[i][2] && arr[i][0] != ' ')
        {
            return arr[i][0];
        }

    }
    //判断三列
    for (i = 0; i < col; i++)
    {
        if (arr[0][i] == arr[1][i] && arr[1][i] == arr[2][i] && arr[0][i] != ' ')
        {
            return arr[0][i];
        }
    }
    //判断2个斜线
    if (arr[0][0] == arr[1][1] && arr[1][1] == arr[2][2] && arr[0][0] != ' ')
    {
        return arr[0][0];
    }
    if (arr[0][2] == arr[1][1] && arr[1][1] == arr[2][0] && arr[2][0] != ' ')
    {
        return arr[0][2];
    }

    //判断是否下满，是否平局
    int len = 0;
    len = is_full(arr, ROW, COL);
    if (len == 1)
    {
        return 'Q';
    }
    else
    {
        return 'C';
    }
}
int Judge_com(char arr[ROW][COL], int row, int col, int z)//电脑判断自己能否胜利
{
    while (z == 0)
    {
        int i = 0;
        for (i = 0; i < row; i++)//判断三行是否有两个‘#’
        {
            if (arr[i][0] == arr[i][1] && arr[i][1] == '0' && arr[i][2] == ' ')
            {
                z = 1;
                arr[i][2] = '0';
                printf("%d %d\n", i + 1, 3);
                break;
            }
            if (arr[i][1] == arr[i][2] && arr[i][2] == '0' && arr[i][0] == ' ')
            {
                z = 1;
                arr[i][0] = '0';
                printf("%d %d\n", i + 1, 1);
                break;
            }
            if (arr[i][0] == arr[i][2] && arr[i][2] == '0' && arr[i][1] == ' ')
            {
                z = 1;
                arr[i][1] = '0';
                printf("%d %d\n", i + 1, 2);
                break;
            }
        }
        if (z != 0)
            break;
        for (i = 0; i < col; i++)//判断三列是否有两个‘#’
        {
            if (arr[0][i] == arr[1][i] && arr[1][i] == '0' && arr[2][i] == ' ')
            {
                z = 1;
                arr[2][i] = '0';
                printf("%d %d\n", 3, i + 1);
                break;
            }
            if (arr[1][i] == arr[2][i] && arr[2][i] == '0' && arr[0][i] == ' ')
            {
                z = 1;
                arr[0][i] = '0';
                printf("%d %d\n", 1, i + 1);
                break;
            }
            if (arr[0][i] == arr[2][i] && arr[2][i] == '0' && arr[1][i] == ' ')
            {
                z = 1;
                arr[1][i] = '0';
                printf("%d %d\n", 2, i + 1);
                break;
            }
        }
        break;
    }
    while (z == 0)//判断两个竖线是否有两个‘#’
    {
        if (arr[0][0] == arr[1][1] && arr[1][1] == '0' && arr[2][2] == ' ')
        {
            z = 1;
            arr[2][2] = '0';
            printf("%d %d\n", 3, 3);
            break;
        }
        if (arr[0][0] == arr[2][2] && arr[2][2] == '0' && arr[1][1] == ' ')
        {
            z = 1;
            arr[1][1] = '0';
            printf("%d %d\n", 2, 2);
            break;
        }
        if (arr[1][1] == arr[2][2] && arr[1][1] == '0' && arr[0][0] == ' ')
        {
            z = 1;
            arr[0][0] = '0';
            printf("%d %d\n", 1, 1);
            break;
        }

        if (arr[0][2] == arr[1][1] && arr[1][1] == '0' && arr[2][0] == ' ')
        {
            z = 1;
            arr[2][0] = '0';
            printf("%d %d\n", 3, 1);
            break;
        }
        if (arr[0][2] == arr[2][0] && arr[0][2] == '0' && arr[1][1] == ' ')
        {
            z = 1;
            arr[1][1] = '0';
            printf("%d %d\n", 2, 2);
            break;
        }
        if (arr[1][1] == arr[2][0] && arr[1][1] == '0' && arr[0][2] == ' ')
        {
            z = 1;
            arr[0][2] = '0';
            printf("%d %d\n", 1, 3);
            break;
        }
        break;
    }
    z = Judge_player(arr, ROW, COL, z);//判断玩家是否要赢，进行拦截
    return z;
}
int Judge_player(char arr[ROW][COL], int row, int col, int z)//判断玩家是否要赢，进行拦截
{
    while (z == 0)
    {
        int i = 0;
        for (i = 0; i < row; i++)//判断玩家3行
        {
            if (arr[i][0] == arr[i][1] && arr[i][1] == '1' && arr[i][2] == ' ')
            {
                z = 1;
                arr[i][2] = '0';
                printf("%d %d\n", i + 1, 3);
                break;
            }
            if (arr[i][1] == arr[i][2] && arr[i][2] == '1' && arr[i][0] == ' ')
            {
                z = 1;
                arr[i][0] = '0';
                printf("%d %d\n", i + 1, 1);
                break;
            }
            if (arr[i][0] == arr[i][2] && arr[i][2] == '1' && arr[i][1] == ' ')
            {
                z = 1;
                arr[i][1] = '0';
                printf("%d %d\n", i + 1, 2);
                break;
            }
        }
        if (z != 0)
            break;
        for (i = 0; i < col; i++)//判断玩家3列
        {
            if (arr[0][i] == arr[1][i] && arr[1][i] == '1' && arr[2][i] == ' ')
            {
                z = 1;
                arr[2][i] = '0';
                printf("%d %d\n", 3, i + 1);
                break;
            }
            if (arr[1][i] == arr[2][i] && arr[2][i] == '1' && arr[0][i] == ' ')
            {
                z = 1;
                arr[0][i] = '0';
                printf("%d %d\n", 1, i + 1);
                break;
            }
            if (arr[0][i] == arr[2][i] && arr[2][i] == '1' && arr[1][i] == ' ')
            {
                z = 1;
                arr[1][i] = '0';
                printf("%d %d\n", 2, i + 1);
                break;
            }
        }
        break;
    }
    while (z == 0)//判断两个斜线
    {
        if (arr[0][0] == arr[1][1] && arr[1][1] == '1' && arr[2][2] == ' ')
        {
            z = 1;
            arr[2][2] = '0';
            printf("%d %d\n", 3, 3);
            break;
        }
        if (arr[0][0] == arr[2][2] && arr[2][2] == '1' && arr[1][1] == ' ')
        {
            z = 1;
            arr[1][1] = '0';
            printf("%d %d\n", 2, 2);
            break;
        }
        if (arr[1][1] == arr[2][2] && arr[1][1] == '1' && arr[0][0] == ' ')
        {
            z = 1;
            arr[0][0] = '0';
            printf("%d %d\n", 1, 1);
            break;
        }

        if (arr[0][2] == arr[1][1] && arr[1][1] == '1' && arr[2][0] == ' ')
        {
            z = 1;
            arr[2][0] = '0';
            printf("%d %d\n", 3, 1);
            break;
        }
        if (arr[0][2] == arr[2][0] && arr[0][2] == '1' && arr[1][1] == ' ')
        {
            z = 1;
            arr[1][1] = '0';
            printf("%d %d\n", 2, 2);
            break;
        }
        if (arr[1][1] == arr[2][0] && arr[1][1] == '1' && arr[0][2] == ' ')
        {
            z = 1;
            arr[0][2] = '0';
            printf("%d %d\n", 1, 3);
            break;
        }
        break;
    }
    return z;
}

总结

以上就是对<进阶版三子棋>的优化完善和改进！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/176764.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【教程】虚拟环境与Pytorch安装

【教程】虚拟环境与Pytorch安装

【教程】虚拟环境与Pytorch安装NVIDIA驱动安装虚拟环境创建激活/删除相关库的安装Pytorch安装安装地址可能遇到的问题处理报错安装卡顿测试是否安装完成参考NVIDIA驱动安装 NVIDIA驱动可在官网进行安装&#xff1a;NVIDIA驱动官网 命令行输入nvidia-smi可查看cuda版本等信息&…
阅读更多...
Linux常用命令——ss命令

Linux常用命令——ss命令

在线Linux命令查询工具(http://www.lzltool.com/LinuxCommand) ss 比 netstat 好用的socket统计信息&#xff0c;iproute2 包附带的另一个工具&#xff0c;允许你查询 socket 的有关统计信息。 补充说明 ss命令用来显示处于活动状态的套接字信息。ss命令可以用来获取socket…
阅读更多...
XGBoost的原理、工程实现与优缺点

XGBoost的原理、工程实现与优缺点

Xgboost简介 XGBoost是陈天奇等人开发的一个开源机器学习项目&#xff0c;高效地实现了GBDT算法并进行了算法和工程上的许多改进&#xff0c;被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。XGBoost本质上还是一个GBDT&#xff0c;但是力争把速度和效率发…
阅读更多...
C++普通类，派生类，虚基类的成员构造顺序以及构造函数调用顺序详解

C++普通类，派生类，虚基类的成员构造顺序以及构造函数调用顺序详解

目录前言普通类构造析构顺序解析依赖关系产生的错误派生类构造析构顺序解析扩展菱形多继承场景含虚基类的派生类构造析构顺序解析扩展菱形多继承场景(引入虚继承)前言 C规定“对象的析构过程必须与其构造过程相反”这一语法规则。 因此我们研究透彻了构造过程&#xff0c;那么…
阅读更多...
宕机了，Redis如何避免数据丢失？

宕机了，Redis如何避免数据丢失？

今天是大年初一&#xff0c;祝大家新年快乐&#xff0c;新的一年技术增进&#xff0c;工资翻倍。 目前&#xff0c;Redis的持久化主要有两大机制&#xff0c;即AOF日志和RDB快照&#xff0c;在接下来的两节课里&#xff0c;我们就分别学习一下吧。 AOF日志是如何实现的&#…
阅读更多...
结构型模式-装饰器模式

结构型模式-装饰器模式

1.概述 快餐店有炒面、炒饭这些快餐&#xff0c;可以额外附加鸡蛋、火腿、培根这些配菜&#xff0c;当然加配菜需要额外加钱&#xff0c;每个配菜的价钱通常不太一样&#xff0c;那么计算总价就会显得比较麻烦。 使用继承的方式存在的问题&#xff1a; 扩展性不好 如果要再加…
阅读更多...
Alibaba微服务组件Sentinel学习笔记

Alibaba微服务组件Sentinel学习笔记

1 .Sentinel 是什么 随着微服务的流行&#xff0c;服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的流量控制组件&#xff0c;主要以 流量为切入点&#xff0c;从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的…
阅读更多...
一篇读懂图神经网络

一篇读懂图神经网络

来源&#xff1a;投稿 作者&#xff1a;张宇 编辑&#xff1a;学姐 近年来&#xff0c;作为一项新兴的图数据学习技术&#xff0c;图神经网络&#xff08;GNN&#xff09;受到了非常广泛的关注&#xff0c;在各大顶级学术会议上&#xff0c;图神经网络相关的论文也占了相当可观…
阅读更多...
https://app.diagrams.net/在线画图的一些技巧

https://app.diagrams.net/在线画图的一些技巧

最近工作需要，实践了在线画图的case, 下面就把使用心得记录一下： 关于diagrams 的一些小技巧： 登入的网页是：Flowchart Maker & Online Diagram Software 1: 利用group 的选项，这个可以整体移动，不用担心会漏掉一个： 就是选中一个图标，然后，看右边arrange 下面…
阅读更多...
20230123使AIO-3568J开发板在Android12下永不休眠

20230123使AIO-3568J开发板在Android12下永不休眠

20230123使AIO-3568J开发板在Android12下永不休眠 2023/1/23 13:59 1、 Z:\android12-rk3568-new\device\rockchip\common\device.mk # Bluetooth HAL PRODUCT_PACKAGES \ libbt-vendor \ android.hardware.bluetooth1.0-impl \ android.hardware.bluetooth1.0-se…
阅读更多...
Hadoop基础之《（1）—大数据基本概念》

Hadoop基础之《（1）—大数据基本概念》

一、Hadoop 1、Hadoop大数据框架&#xff0c;处理分布式环境下数据存储和计算 2、Hadoop的HDFS处理存储 3、Hadoop的MapReduce处理计算 map让任务数据拆分到每一台去执行 reduce处理后的任务合并 4、Hive作用是在Hadoop上能够让用户来写SQL处理数据 Hive的执行引擎&#xff0c;…
阅读更多...
深度学习TensorFlow—GPU2.4.0版环境配置，一文简单易懂详细大全，CUDA11.0、cuDNN8.0

深度学习TensorFlow—GPU2.4.0版环境配置，一文简单易懂详细大全，CUDA11.0、cuDNN8.0

深度学习TensorFlow—GPU2.4.0版环境配置&#xff0c;一文简单易懂详细大全&#xff0c;CUDA11.0、cuDNN8.0 前提&#xff1a;电脑拥有英伟达独立显卡!!!&#xff0c;并且安装了anaconda&#xff01;&#xff01;&#xff01; 前提&#xff1a;电脑拥有英伟达独立显卡!!!&…
阅读更多...
vue事件车之兄弟组件之间传值

vue事件车之兄弟组件之间传值

目录前言一&#xff0c;全局事件总线介绍1.1 原理介绍1.2 x需要满足的条件二&#xff0c;知识点的复习2.1 vc是什么2.2 vm管理vc如何体现2.3 原型2.4 上述知识的串联三&#xff0c;实现需求3.1 x的编写及讲解3.2 使用x四&#xff0c;标准写法4.1 写法改动4.2 销毁五 关键代码后…
阅读更多...
兔年首文迎新春-Cesium橘子洲烟花礼赞

兔年首文迎新春-Cesium橘子洲烟花礼赞

兔年新春今天是兔年大年初二&#xff0c;神州大地&#xff0c;在经历了疫情的三年后迎来开放的一个春节。大家都沉浸在欢乐幸福的春节气氛中。玉兔迎新春&#xff0c;祝福齐送到&#xff1a;白兔祝你身体安康&#xff0c;黑兔祝你薪水高涨&#xff0c;灰兔送你梦想如意&#xf…
阅读更多...
Maven高级

Maven高级

Maven高级 1&#xff0c;分模块开发 1.1 分模块开发设计 (1)按照功能拆分 我们现在的项目都是在一个模块中&#xff0c;比如前面的SSM整合开发。虽然这样做功能也都实现了&#xff0c;但是也存在了一些问题&#xff0c;我们拿银行的项目为例来聊聊这个事。 网络没有那么发…
阅读更多...
Java多线程03——等待唤醒机制(and阻塞队列实现)

Java多线程03——等待唤醒机制(and阻塞队列实现)

目录1.等待唤醒机制1.ThreadDemo2.Desk3.Cook4.Foodie2.等待唤醒机制&#xff08;阻塞队列方式实现&#xff09;1.ThreadDemo022.Cook023.Foodie023.线程的状态1.等待唤醒机制 生产者和消费者 桌子上有食物&#xff0c;消费者吃&#xff0c;桌子上没有食物&#xff0c;消费者等…
阅读更多...
ElasticSearch 索引模板 组件模板 组合模板详细使用介绍

ElasticSearch 索引模板 组件模板 组合模板详细使用介绍

索引模板_template 文章目录索引模板_templateTemplate 介绍索引模板Index Template参数说明创建一个索引模板 Index Template测试不存在的索引直接添加数据创建索引总结组合索引模板 Index Template 7.8版本之后引入创建基于组件模板的索引模板 Index Template创建组件模板模拟…
阅读更多...
LeetCode103_ 103. 二叉树的锯齿形层序遍历

LeetCode103_ 103. 二叉树的锯齿形层序遍历

LeetCode103_ 103. 二叉树的锯齿形层序遍历 一、描述 给你二叉树的根节点 root &#xff0c;返回其节点值的 锯齿形层序遍历 。&#xff08;即先从左往右&#xff0c;再从右往左进行下一层遍历&#xff0c;以此类推&#xff0c;层与层之间交替进行&#xff09;。 示例 1&…
阅读更多...
【头歌】顺序表的基本操作

【头歌】顺序表的基本操作

第1关&#xff1a;顺序表的插入操作任务描述本关任务&#xff1a;编写顺序表的初始化、插入、遍历三个基本操作函数。相关知识顺序表的存储结构顺序表的存储结构可以借助于高级程序设计语言中的数组来表示&#xff0c;一维数组的下标与元素在线性表中的序号相对应。线性表的顺序…
阅读更多...
YOLOv5/v7 引入 YOLOv8 的 C2f 模块

YOLOv5/v7 引入 YOLOv8 的 C2f 模块

YOLOv8 项目地址&#xff1a;https://github.com/ultralytics/ultralytics YOLOv8 Ultralytics YOLOv8 是由 Ultralytics 开发的一个前沿的 SOTA 模型。它在以前成功的 YOLO 版本基础上&#xff0c;引入了新的功能和改进&#xff0c;进一步提升了其性能和灵活性。YOLOv8 基于快…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023