精华内容
下载资源
问答
  • C语言如何一个最简单的小型迷宫游戏 这篇文章是给学完并学懂了C语言的分支(选择和循环)结构和二维数组朋友看。 要一个游戏或者程序先要想好有那些要求,以下是我认为一个简单迷宫必带要求: 迷宫要先...

    C语言如何做一个最简单的小型迷宫游戏

    这篇文章是给学完并学懂了C语言的分支(选择和循环)结构和二维数组的朋友看的。

    要做一个游戏或者程序先要想好有那些要求,以下是我认为一个简单迷宫必带的要求: 

    1. 迷宫要先打印出来(要设置墙、空气、小球的起点),是墙就不能,是空气就可以走。
    2. 每次输入'w'、'a'、's'、'd'为上、左、下、右,并每次输入后,不用按回车或任意键继续就能输出,每次走一步(按键盘的键走)后,先清屏再输出现在迷宫以及小球现在在哪里。
    3. 要有起点和终点的X、Y轴,如果小球与终点的位置相同了,就提示胜利并退出游戏。 

    首先我们要打印出地图,因为地图有长和宽的长度,所以我们要用二维数组来定义一个地图,代码如下:

        char map[50][50]={
                        "######",//申请50*50的二维字符串当迷宫地图,但这里是6*6的地图
                        "#O #  ",//'#'是墙(不可以走的地方)
                        "# ## #",//'O'是起点(可控制)
                        "#  # #",//' '是空气(可以走的地方)
                        "##   #",
                        "######",//横竖都是012345,012345(数组下标从0开始)
                        };

    定义完二维数组,就要把它打印出来,代码如下:

    int i,j;
        for(i=0;i<6;i++)//i循环用来控制打印地图的行数
        {
            for(j=0;j<6;j++)//j循环用来控制打印地图的列数
            {
                printf("%c",map[i][j]);//打印每次i和j的行数和列数
            }
            printf("\n");//一行打印完毕需要换行
        }

    上面这段代码是通过双重循环打印出地图的每行每列。

    如果学过puts函数来输出字符数组的朋友可以这样写,代码如下:

    int i;
    for (i=0;i<6;i++)//从0到5,共进行了6次循环,依次输出迷宫的第0至5行
            puts(map[i]);//表示输出每一行的字符串

    是不是简单了许多,不懂puts函数的朋友也没关系,你用第一种方法就行,对于puts函数你只需要知道:

    1. 使用 puts() 显示字符串时,系统会自动在其后添加一个换行符。
    2. 只有遇到 '\0' 也就是字符串结束标志符才会停止。

    然后再定义起点和终点的X、Y轴位置(当然上面定义二维数组时已经看得出来了),代码如下:

    ​int x,y,p,q;//x,y为小球(起点"O")初始位置竖横轴 
                //p,q为空白(终点" ")结束位置竖横轴
    x=1;y=1;//x为竖轴初始位置为1,y为初始横轴位置为1
    p=1;q=5;//p为竖轴结束位置为1,q为结束横轴位置为5

    目前为止,我们做了定义地图、输出地图、和定义起点终点的X、Y轴,目前全部代码如下:

    #include <stdio.h>//printf("");的头文件
    #include <stdlib.h>//system("");的头文件
    #include <Windows.h>//Sleep();的头文件
    int m1ain(void)
    {
        char map[50][50]={
                            "######",//申请50*50的二维字符串当迷宫地图,但这里是6*6的地图
                            "#O #  ",//'#'是墙(不可以走的地方)
                            "# ## #",//'O'是起点(可控制)
                            "#  # #",//' '是空气(可以走的地方)
                            "##   #",
                            "######",//横竖都是012345,012345(数组下标从0开始)
                            };
        int i,x,y,p,q;//x,y为小球(起点"O")初始位置竖横轴 
                      //p,q为空白(终点" ")结束位置竖横轴
        int ch;//申请需要输入的字符(名称是ch),当移动(w,a,s,d)
        x=1;y=1;p=1;q=5;//x为竖轴初始位置为1,y为初始横轴位置为1
                        //p为竖轴结束位置为1,q为结束横轴位置为5
        for (i=0;i<6;i++)//从0到5,共进行了6次循环,依次输出迷宫的第0至5行
            puts(map[i]);//表示输出每一行的字符串
        Sleep(5000);//上面代码全部执行完毕后过五秒自动关闭程序
        return 0;
    }

    现在我们就要想办法控制小球了,这里利用键盘上的'w''s''a''d'四个键来控制这个小球进行上、下、左、右移动,当然你如果喜欢,也可以用别的按键。

    第一步:先来控制小球向下移动,也就是当你按下's'键时,小球向下移动一步。

    那么如何获得's'这个按键呢,换句话说:当你按下's'键时,我们的程序怎样知道你按的是's'键呢?

    很简单,因为你按下's'键时,本质上是输入了1个字符's',我们只需要读取这个字符's'就可以了,读取一个字符有4种方法:

    char ch;
    scanf("%c",&ch);//读取一个字符,输入后等待用户按"Enter"键结束(带回显)
    ch=getchar;//读取一个字符,输入后等待用户按"Enter"键结束(带回显)
    ch=getche;//读取一个字符,输入后立即获取字符,不用按"Enter"键结束(带回显)
    ch=getch;//读取一个字符,输入后立即获取字符,不用按"Enter"键结束(不带回显)

    而我们并不想显示输入的字符,并且希望输入的字符可以立即被程序获得,而不用在敲击一个字符后再敲击一个"Enter"键。

    因此我们选用最后一个语句ch=getch();。

    接下来,我们要把在键盘上敲击的字符存储在字符变量ch中,再接下来实现当敲击's'时。让小球向下移动一步,代码如下:

    ​if (ch=='s')//判断你是否输入(按)'s'这个字符
    {
        if (map[x+1][y]!='#')//确认输入(按)的是's'时,就执行[x+1][y](往下走,x为竖轴,+1为往下,y不变),提前是还要判断往下走是否为'#'(墙)
            {                       
                map[x][y]=' ';//确认往下走不是墙时,把当前的'O'输出成' '
                x++;//为向下走
                map[x][y]='O';//确认往下走不是墙时,把下一步的' '输出成'O'
            }
    }

    在上面代码中,我们通过if语句来判断敲击的字符是否是字符's',如果是字符's',我们就让小球向下移动一步,但在小球向下移动之前,需要首先判断下面一步是否能移动,只有下一步不是墙'#'时小球才能移动。

    也就是说当if(map[x+1][y]!='#')条件成立时,就表示下一步不是墙,小球可以移动。

    可能有些朋友会问:为什么[x+1][y]就表示向下走一部的格子呢?

    其实很简单:向下移动时,小球当然还在当前这个列,不过不在这一行,而是在下一行,因此向下移动是y不变,x加1。

    如果是向右边移动,很显然还是在同一行,所以x不变,但是小球已经不在刚才那一竖列了,而在右边的一个竖列,因此y需要加1。

    小球移动总结如下:

    • 向下移动是y不变,x加1。
    • 向上移动是y不变,x减1。
    • 向左移动是x不变,y减1。
    • 向右移动是x不变,y加1。

    接下来我们来讲解下面这3句话的意思:

    map[x][y]=' ';//确认往下走不是墙时,把当前的'O'输出成' '
    x++;//为向下走
    map[x][y]='O';//确认往下走不是墙时,把下一步的' '输出成'O'

    让小球向下移动,就是让小球原本位置上的'O'变成空格,而让下一个空格变成'O'。

    第一句:map[x][y]=' ';(注意此处两个单引号之间中间有一个空格)就是让小球的当前位置变为空格,

    第二句:x++;这句话非常重要,它表示更改小球的位置,因为小球向下运动只需要x++就可以了,y不变。

    第三句:a[x][y]='O';语句就是将小球新位置上的内容替换为小球'O'。

    请注意上面一个代码,可不能写成:

    map[x][y]=' ';           
    map[x+1][y]='O';

    至于为什么,大家自己去想想吧!

    因为小球的位置有了变化,因此还需要将新迷宫的状态重新打印一次,在打印之前记得要将之前的屏幕清屏,代码如下:

    system("cls");//每次移动了小球就清屏一次
    for(i=0;i<6;i++)//清屏了再次循环输出新的地图
        puts(map[i]);//清屏了再次输出新的地图

     好了,再进行一次小结:

    ​#include <stdio.h>//printf("");的头文件
    #include <stdlib.h>//system("");的头文件
    #include <Windows.h>//Sleep();的头文件
    #include <conio.h>//getch();的头文件
    int m1ain(void)
    {
        char map[50][50]={
                            "######",//申请50*50的二维字符串当迷宫地图,但这里是6*6的地图
                            "#O #  ",//'#'是墙(不可以走的地方)
                            "# ## #",//'O'是起点(可控制)
                            "#  # #",//' '是空气(可以走的地方)
                            "##   #",
                            "######",//横竖都是012345,012345(数组下标从0开始)
                            };
        int i,x,y,p,q;//x,y为小球(起点"O")初始位置竖横轴 
                      //p,q为空白(终点" ")结束位置竖横轴
        int ch;//申请需要输入的字符(名称是ch),当移动(w,a,s,d)
        x=1;y=1;p=1;q=5;//x为竖轴初始位置为1,y为初始横轴位置为1
                        //p为竖轴结束位置为1,q为结束横轴位置为5
        for (i=0;i<6;i++)//从0到5,共进行了6次循环,依次输出迷宫的第0至5行
            puts(map[i]);//表示输出每一行的字符串
        ch=getch();//这语句表示给ch变量输入的字符可以立即被程序获取(不用按任意键继续),也不会回显
        if (ch=='s')//判断你是否输入(按)'s'这个字符
        {
            if (map[x+1][y]!='#')//确认输入(按)的是's'时,就执行[x+1][y](往下走,x为竖轴,+1为往下,y不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往下走不是墙时,把当前的'O'输出成' '
                    x++;//为向下走
                    map[x][y]='O';//确认往下走不是墙时,把下一步的' '输出成'O'
                }
        }
        system("cls");//每次移动了小球就清屏一次
        for(i=0;i<6;i++)//清屏了再次循环输出新的地图
           puts(map[i]);//清屏了再次输出新的地图
        Sleep(5000);//上面代码全部执行完毕后过五秒自动关闭程序
        return 0;
    }

    运行一下,然后按一下's'键,是不是已经可以看到小球向下移动了一步了呢?

    但是你只能移动一步,如何实现连续移动呢?

    很简单,我们可以通过while循环来解决问题:

    #include <stdio.h>//printf("");的头文件
    #include <stdlib.h>//system("");的头文件
    #include <Windows.h>//Sleep();的头文件
    #include <conio.h>//getch();的头文件
    int m1ain(void)
    {
        char map[50][50]={
                            "######",//申请50*50的二维字符串当迷宫地图,但这里是6*6的地图
                            "#O #  ",//'#'是墙(不可以走的地方)
                            "# ## #",//'O'是起点(可控制)
                            "#  # #",//' '是空气(可以走的地方)
                            "##   #",
                            "######",//横竖都是012345,012345(数组下标从0开始)
                            };
        int i,x,y,p,q;//x,y为小球(起点"O")初始位置竖横轴 
                      //p,q为空白(终点" ")结束位置竖横轴
        int ch;//申请需要输入的字符(名称是ch),当移动(w,a,s,d)
        x=1;y=1;p=1;q=5;//x为竖轴初始位置为1,y为初始横轴位置为1
                        //p为竖轴结束位置为1,q为结束横轴位置为5
        for (i=0;i<6;i++)//从0到5,共进行了6次循环,依次输出迷宫的第0至5行
            puts(map[i]);//表示输出每一行的字符串
        while(1)//暂时无限循环
        {
            ch=getch();//这语句表示给ch变量输入的字符可以立即被程序获取(不用按任意键继续),也不会回显
            if (ch=='s')//判断你是否输入(按)'s'这个字符
            {
                if (map[x+1][y]!='#')//确认输入(按)的是's'时,就执行[x+1][y](往下走,x为竖轴,+1为往下,y不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往下走不是墙时,把当前的'O'输出成' '
                    x++;//为向下走
                    map[x][y]='O';//确认往下走不是墙时,把下一步的' '输出成'O'
                }
            }
            system("cls");//每次移动了小球就清屏一次
            for(i=0;i<6;i++)//清屏了再次循环输出新的地图
               puts(map[i]);//清屏了再次输出新的地图
        }
        Sleep(5000);//上面代码全部执行完毕后过五秒自动关闭程序
        return 0;
    }

    暂时先使用while(1)无限循环来解决这个问题,好了,运行一下吧。

    此时小球是不是可以连续移动了?

    当然,目前小球还只能朝一个方向运动,接下来我们来实现小球向其它3个方向的运动。

    向其它3个方向移动其实和"向下移动"是差不多的,只要注意是x在变化还是y在变化,是加1还是减1就可以了。无限移动4个方向代码如下:

    #include <stdio.h>//printf("");的头文件
    #include <stdlib.h>//system("");的头文件
    #include <Windows.h>//Sleep();的头文件
    #include <conio.h>//getch();的头文件
    int m1ain(void)
    {
        char map[50][50]={
                            "######",//申请50*50的二维字符串当迷宫地图,但这里是6*6的地图
                            "#O #  ",//'#'是墙(不可以走的地方)
                            "# ## #",//'O'是起点(可控制)
                            "#  # #",//' '是空气(可以走的地方)
                            "##   #",
                            "######",//横竖都是012345,012345(数组下标从0开始)
                            };
        int i,x,y,p,q;//x,y为小球(起点"O")初始位置竖横轴 
                      //p,q为空白(终点" ")结束位置竖横轴
        int ch;//申请需要输入的字符(名称是ch),当移动(w,a,s,d)
        x=1;y=1;p=1;q=5;//x为竖轴初始位置为1,y为初始横轴位置为1
                        //p为竖轴结束位置为1,q为结束横轴位置为5
        for (i=0;i<6;i++)//从0到5,共进行了6次循环,依次输出迷宫的第0至5行
            puts(map[i]);//表示输出每一行的字符串
        while(1)//暂时无限循环
        {
            ch=getch();//这语句表示给ch变量输入的字符可以立即被程序获取(不用按任意键继续),也不会回显
            if (ch=='s')//判断你是否输入(按)'s'这个字符
            {
                if (map[x+1][y]!='#')//确认输入(按)的是's'时,就执行[x+1][y](往下走,x为竖轴,+1为往下,y不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往下走不是墙时,把当前的'O'输出成' '
                    x++;//为向下走
                    map[x][y]='O';//确认往下走不是墙时,把下一步的' '输出成'O'
                }
            }
            if (ch=='w')//判断你是否输入(按)'w'这个字符
            {
                if (map[x-1][y]!='#')//确认输入(按)的是'w'时,就执行[x-1][y](往上走,x为竖轴,-1为往上,y不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往上走不是墙时,把当前的'O'输出成' '
                    x--;//为向上走
                    map[x][y]='O';//确认往上走不是墙时,把下一步的' '输出成'O'
                }
            }
            if (ch=='a')//判断你是否输入(按)'a'这个字符
            {
                if (map[x][y-1]!='#')//确认输入(按)的是'a'时,就执行[x][y-1](往左走,y为横轴,-1为往左,x不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往左走不是墙时,把当前的'O'输出成' '
                    y--;//为向左走
                    map[x][y]='O';//确认往左走不是墙时,把下一步的' '输出成'O'
                }
            }
            if (ch=='d')//判断你是否输入(按)'d'这个字符
            {
                if (map[x][y+1]!='#')//确认输入(按)的是'd'时,就执行[x][y-1](往右走,y为横轴,+1为往右,x不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往右走不是墙时,把当前的'O'输出成' '
                    y++;//为向右走
                    map[x][y]='O';//确认往右走不是墙时,把下一步的' '输出成'O'
                }
            }
            system("cls");//每次移动了小球就清屏一次
            for(i=0;i<6;i++)//清屏了再次循环输出新的地图
               puts(map[i]);//清屏了再次输出新的地图
        }
        Sleep(5000);//上面代码全部执行完毕后过五秒自动关闭程序
        return 0;
    }

    好了,你是不是已经成功走出了迷宫?

    可是貌似程序并没有让你很惊喜,因为没有判定你已经成功走出迷宫。

    最后我们来写一个"获胜"的检测部分,其实只需要将我们之前写的while(1)改为while(x!=p||y!=q)就可以了。

    还记得吗,之前我们用p和q分别存储了迷宫出口的坐标位置,当然了,在最后我们需要打印"你获胜了"。完整代码如下:

    #include <stdio.h>//printf("");的头文件
    #include <stdlib.h>//system("");的头文件
    #include <Windows.h>//Sleep();的头文件
    #include <conio.h>//getch();的头文件
    int m1ain(void)
    {
        printf("欢迎来到迷宫小游戏\n");//介绍这个迷宫游戏
        printf("操作方式:\nw为往上走\ns为往下走\na为往左走\nd为往右走\n");//介绍操作方式
        char map[50][50]={
                            "######",//申请50*50的二维字符串当迷宫地图,但这里是6*6的地图
                            "#O #  ",//'#'是墙(不可以走的地方)
                            "# ## #",//'O'是起点(可控制)
                            "#  # #",//' '是空气(可以走的地方)
                            "##   #",
                            "######",//横竖都是012345,012345(数组下标从0开始)
                            };
        int i,x,y,p,q;//x,y为小球(起点"O")初始位置竖横轴 
                      //p,q为空白(终点" ")结束位置竖横轴
        int ch;//申请需要输入的字符(名称是ch),当移动(w,a,s,d)
        x=1;y=1;p=1;q=5;//x为竖轴初始位置为1,y为初始横轴位置为1
                        //p为竖轴结束位置为1,q为结束横轴位置为5
        for (i=0;i<6;i++)//从0到5,共进行了6次循环,依次输出迷宫的第0至5行
            puts(map[i]);//表示输出每一行的字符串
         while (x!=p||y!=q)//只要x的值不等p或y的值不等q就无限循环   
        {
            ch=getch();//这语句表示给ch变量输入的字符可以立即被程序获取(不用按任意键继续),也不会回显
            if (ch=='s')//判断你是否输入(按)'s'这个字符
            {
                if (map[x+1][y]!='#')//确认输入(按)的是's'时,就执行[x+1][y](往下走,x为竖轴,+1为往下,y不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往下走不是墙时,把当前的'O'输出成' '
                    x++;//为向下走
                    map[x][y]='O';//确认往下走不是墙时,把下一步的' '输出成'O'
                }
            }
            if (ch=='w')//判断你是否输入(按)'w'这个字符
            {
                if (map[x-1][y]!='#')//确认输入(按)的是'w'时,就执行[x-1][y](往上走,x为竖轴,-1为往上,y不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往上走不是墙时,把当前的'O'输出成' '
                    x--;//为向上走
                    map[x][y]='O';//确认往上走不是墙时,把下一步的' '输出成'O'
                }
            }
            if (ch=='a')//判断你是否输入(按)'a'这个字符
            {
                if (map[x][y-1]!='#')//确认输入(按)的是'a'时,就执行[x][y-1](往左走,y为横轴,-1为往左,x不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往左走不是墙时,把当前的'O'输出成' '
                    y--;//为向左走
                    map[x][y]='O';//确认往左走不是墙时,把下一步的' '输出成'O'
                }
            }
            if (ch=='d')//判断你是否输入(按)'d'这个字符
            {
                if (map[x][y+1]!='#')//确认输入(按)的是'd'时,就执行[x][y-1](往右走,y为横轴,+1为往右,x不变),提前是还要判断往下走是否为'#'(墙)
                {                       
                    map[x][y]=' ';//确认往右走不是墙时,把当前的'O'输出成' '
                    y++;//为向右走
                    map[x][y]='O';//确认往右走不是墙时,把下一步的' '输出成'O'
                }
            }
            system("cls");//每次移动了小球就清屏一次
            for(i=0;i<6;i++)//清屏了再次循环输出新的地图
               puts(map[i]);//清屏了再次输出新的地图
        }
        system("cls");//最后通关后清屏
        printf("恭喜你赢了!\n");//最后通关后提示输出语句
        Sleep(5000);//上面代码全部执行完毕后过五秒自动关闭程序
        return 0;
    }

    恭喜,你已经成功搞定一个完整的"走迷宫"程序,太不容易啦!

    当然也可以让迷宫更加复杂,更加好玩,赶快与你的朋友们分享吧!

    展开全文
  • C语言简单实现扫雷小游戏~~~

    千次阅读 2017-07-24 15:29:21
    C语言编写小游戏扫雷,因为目前个人技术问题,外观界面不能做出来,最终呈现效果还是在命令里进行,但是总体来说还是完成了扫雷基本功能。 不过,标记函数,没有写完美,每次都要进行标记,比较麻烦,所以...

    C语言实现扫雷

    C语言编写小游戏扫雷,因为目前个人技术问题,外观界面不能做出来,最终呈现的效果还是在命令里进行,但是总体来说还是完成了扫雷的基本功能。
    不过,标记的函数,没有写的完美,每次都要进行标记,比较麻烦,所以在代码中我将其注释了,若有人能够有好的算法的话,还请不吝赐教。
    代码见下:
    #define _CRT_SECURE_NO_WARNINGS 1
    
    #ifndef __GAME_H__
    #define __GAME_H__
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    
    #define ROW 9
    #define COL 9
    
    #define ROWS (ROW+2)
    #define COLS (COL+2)
    
    #define EASY 10
    #define HARD 80
    
    void Init_Array(char Array[ROWS][COLS], int row, int col, char set); //初始化数组
    void Display(char Array[ROWS][COLS], int row, int col);  //打印数组
    void Set_Mine(char Array[ROWS][COLS], int MINE);  //布雷
    void Sweep_Mine(char Array[ROWS][COLS], char show[ROWS][COLS], int row, int col, int MINE);  //扫雷
    void Move_mine(char Array[ROWS][COLS], int x, int y);  //移雷
    void Get_Mine_Count(char Array[ROWS][COLS], char show[ROWS][COLS], int x, int y);  //区域展开
    
    #endif //__GAME_H__ 
    
    
    void game()  //游戏函数
    {
    	int input = 0;
    	int MINE = 0;
    	char mine[ROWS][COLS]; 
    	char show[ROWS][COLS];
    	Init_Array(mine, ROWS, COLS, '0');
    	Init_Array(show, ROWS, COLS, '*');
    	printf("***********  1.EASY    2.HARD  ***********\n");
    	printf("\n请输入选择的难度:< ");
    	scanf("%d", &input);
    
    	switch (input)
    	{
    	case 1:
    		MINE = EASY;
    		break;
    	case 2:
    		MINE = HARD;
    		break;
    	default:printf("您的输入有误!\n");
    	}
    
    	printf("\n这个棋盘有%d处雷,小心咯!!!\n\n", MINE);
    	Set_Mine(mine, MINE);
    	Display(show, ROW, COL);
    	Sweep_Mine(mine, show, ROW, COL, MINE);
    }
    
    void menu()
    {
    	printf("******************************************\n");
    	printf("***********    欢迎来到扫雷    ***********\n");
    	printf("***********  1.PLAY    0.EXIT  ***********\n");
    	printf("******************************************\n");
    }
    
    void test()
    {
    	int input;
    
    	do
    	{
    		srand((unsigned int)rand(NULL));
    		menu();
    		printf("\n请选择:< ");
    		scanf("%d", &input);
    		printf("\n");
    		switch (input)
    		{
    		case 1:
    			game();
    			break;
    		case 0:
    			printf("您已退出游戏,谢谢!\n");
    			break;
    		default:
    			printf("输入不合法,请重新输入!\n");
    			break;
    		}
    	} while (input);
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    
    
    void Init_Array(char Array[ROWS][COLS], int row, int col, char set)
    {
    	memset(Array, set, (row*col*sizeof(Array[0][0])));  //初始化数组内容为0与*
    }
    
    void Display(char Array[ROWS][COLS], int row, int col)
    {
    	int i = 0;
    	int j = 0;
    	printf("      ");
    
    	for (i = 1; i <= row; i++)
    		printf(" %d  ", i);
    	printf("\n      -----------------------------------\n");
    
    	for (i = 1; i <= col; i++)   //因涉及周围展开,故数组从1开始打印
    	{
    		printf("   %d |", i);
    		for (j = 1; j <= col; j++)
    		{
    			printf(" %c |", Array[i][j]);
    		}
    		printf("\n     |---|---|---|---|---|---|---|---|---|\n");
    	}
    	printf("\n");
    }
    
    void Set_Mine(char Array[ROWS][COLS], int MINE)  //布雷
    {
    	int count = MINE;
    	int x = 0;
    	int y = 0;
    
    	while (count)
    	{
    		x = rand() % ROW + 1;
    		y = rand() % COL + 1;
    
    		if (Array[x][y] == '0')
    		{
    			Array[x][y] = '1';
    			count--;
    		}
    	}
    }
    
    //若输入的坐标无雷,则要遍历周围,统计雷数
    //若周围无雷,则递归遍历,统计周围雷数
    void Get_Mine_Count(char Array[ROWS][COLS], char show[ROWS][COLS], int x, int y) 
    {                                                                                 
    		if ((Array[x][y] == '0'))
    		{
    			int count = 0;
    
    			if (Array[x - 1][y - 1] == '1')
    				count++;
    
    			if (Array[x - 1][y] == '1')
    				count++;
    
    			if (Array[x - 1][y + 1] == '1')
    				count++;
    
    			if (Array[x][y - 1] == '1')
    				count++;
    
    			if (Array[x][y + 1] == '1')
    				count++;
    			if (Array[x + 1][y - 1] == '1')
    				count++;
    
    			if (Array[x + 1][y] == '1')
    				count++;
    
    			if (Array[x + 1][y + 1] == '1')
    				count++;
    
    			show[x][y] = (count + '0');
    		}
    
    		if (show[x][y] == '0')
    		{
    			if (show[x - 1][y - 1] == '*')
    				Get_Mine_Count(Array, show, x - 1, y - 1);
    
    			if (show[x - 1][y] == '*')
    				Get_Mine_Count(Array, show, x - 1, y);
    
    			if (show[x - 1][y + 1] == '*')
    				Get_Mine_Count(Array, show, x - 1, y + 1);
    
    			if (show[x][y - 1] == '*')
    				Get_Mine_Count(Array, show, x, y - 1);
    
    			if (show[x][y + 1] == '*')
    				Get_Mine_Count(Array, show, x, y + 1);
    
    			if (show[x + 1][y - 1] == '*')
    				Get_Mine_Count(Array, show, x + 1, y - 1);
    
    			if (show[x + 1][y] == '*')
    				Get_Mine_Count(Array, show, x + 1, y);
    
    			if (show[x + 1][y + 1] == '*')
    				Get_Mine_Count(Array, show, x + 1, y + 1);
    		}
    }
    
    //为提高游戏体验,设置玩家第一次无论如何都不会被炸死
    void Move_mine(char Array[ROWS][COLS], int x, int y)   
    {
    	int ret = 1;
    	do
    	{
    		Array[x][y] = '0';
    		while (ret)
    		{
    			x = rand() % ROW + 1;
    			y = rand() % COL + 1;
    			if (Array[x][y] == '0')
    			{
    				Array[x][y] = '1';
    			}
    			ret--;
    		}
    	} while (ret);
    }
    
    //玩家对以确定的雷的位置,可以进行标记
    //void Mark_Mine(char show[ROWS][COLS])   
    //{
    //	int x = 0;
    //	int y = 0;
    //	printf("请输入您要标记的位置(不标记请输入0,0):<");
    //	scanf("%d%d", &x, &y);
    //	printf("\n");
    //	if (x == 0 && y == 0)
    //		return 0;
    //	else
    //		show[x][y] = '$';
    //}
    
    
    void Sweep_Mine(char Array[ROWS][COLS], char show[ROWS][COLS], int row, int col, int MINE)
    {
    	int x = 0;
    	int y = 0;
    	int count = 0;
    	int temp = 0;
    	int win = 0;
    
    	while (win<(row*col - MINE))
    	{
    		printf("请输入您要扫雷的坐标:<");
    		scanf("%d%d", &x, &y);
    		temp++;
    
    		if (((x >= 1) && (x <= row)) && (y >= 1) && (y <= col))
    		{
    			while ((Array[x][y] == '1') && (temp == 1))
    			{
    				Move_mine(Array, x, y);    //保证玩家第一次不会被炸死,移走雷
    				Get_Mine_Count(Array, show, x, y);  //对周围的雷数进行遍历
    			}
    
    			if (Array[x][y] == '1')
    			{
    				printf("\n哈哈,你被炸死啦!\n\n");
    				Display(Array, ROW, COL);
    				break;
    			}
    			else
    			{
    				Get_Mine_Count(Array, show, x, y);
    				printf("\n\n");
    				win++;
    			}
    			Display(show, ROW, COL);
    			//Mark_Mine(show);
    		}
    		else
    		{
    			printf("坐标输入有误,请重新输入!\n");
    		}
    	}
    
    	if (win == (row*col - MINE))
    		printf("恭喜你,排完了所有的雷!\n");
    }
    运行结果如下:                                                                                                                          



    展开全文
  • 经历了一下午艰苦奋斗,菜鸟努力终于得到了小小回报,虽然这个游戏简单简单,但是对于身为菜鸟我着实有点飘了,对代码兴趣日益增加,希望给和我一样的小可爱带去快乐,更重要给你们带去知识...

    经历了一下午的艰苦奋斗,菜鸟的努力终于得到了小小的回报,虽然这个游戏很简单很简单,但是对于身为小菜鸟的我着实有点飘了,对代码的兴趣日益增加,希望能给和我一样的小可爱带去快乐,更重要的是能给你们带去知识上的帮助,也同时迫切的渴望有大佬能给你提提优化代码的建议,在下不胜感激,下面附上代码。

    今天能做完的事,绝不拖到明天----苏步青

    #define _CRT_SECURE_NO_WARNINGS 1
    #include<stdio.h>
    #include<time.h>
    #include<stdlib.h>
    void menu()
    {
    	printf("********************\n");
    	printf("***** 1.play  *******\n");
    	printf("***** 2.exit  *******\n");
    	printf("********************\n");
    }
    void game()
    {
    	int input = 0;
    	int num = rand()%100+1;
    	while (1)
    	{
    		printf("请输入要猜的数字:");
    		scanf("%d",&input);
    		if (input > num)
    		{ 
    			printf("猜大了\n");
    		}
    		else if (input < num)
    		{
    			printf("猜小了\n");
    		}
    		else
    		{
    			printf("猜对了\n");
    			break;
    		}
    	}
    }
    int main()
    {
    	int input = 0;
    	srand((unsigned int)time(NULL));
    	do{
    		menu();
    		printf("请选择<:");
    		scanf("%d", &input);
    		switch (input)
    		{
    		case 1:
    			game();
    			break;
    		case 0:
    			printf("退出游戏/n");
    			break;
    		default:
    			printf("输入错误,请重新输入!\n");
    			break;
    		}
    	} while (input);
    	system("pause");
    	return 0;
    }
    

    本代码用到的知识点是,基本循环,简单函数,时间戳。
    本代码由本人亲自调试,如有疑问,请联系我,qq1846074273.
    不努力的菜鸟,不是好菜鸟。skr

    展开全文
  •   三子棋小游戏对于初学者来说其实不算太简单,但是只要仔细分析一波也是能做下去,从三子棋游戏玩步骤来一步一步写出相应代码,将每个部分区域化,写成函数,这样读起来以及写起来也会方便许多!...

    简介

      三子棋小游戏对于初学者来说其实不算太简单,但是只要仔细分析一波也是能做下去的,从三子棋游戏玩的步骤来一步一步的写出相应的代码,将每个部分区域化,写成函数,这样读起来以及写起来也会方便许多!
      废话不多说,紧接着看正文!!!

    正文

      三子棋游戏玩的过程可以简述为:电脑下一步棋—>你下一步棋—>电脑下一步棋…依次类推,直到下出结果。
      那么就可以将电脑下的过程和人下的过程分别写成函数,然后下到最后将判断输赢的过程写成一个函数。开始进行之前肯定需要一个棋盘,那么就将棋盘的初始化和打印棋盘分别写成函数。
      首先我们创建自己的头文件game.h,然后将函数的声明以及宏定义放进去方便后期函数管理以及修改

    //这是game.h里的内容
    #ifndef __GAME_H__
    #define __GAME_H__
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #include<windows.h>
    
    #define ROW 3
    #define COL 3
    
    void Init_board(char board[ROW][COL],int row,int col);
    void Display_board(char board[ROW][COL],int row,int col);
    void Player_move(char board[ROW][COL],int row,int col);
    void Computer_move(char board[ROW][COL],int row,int col);
    void game();
    int Is_full(char board[ROW][COL],int row,int col);
    
    
    //Is_win
    //'*'玩家赢
    //'o'电脑赢
    //'q'平局
    //' '再来
    char Is_win(char board[ROW][COL],int row,int col);
    
    #endif//__GAME_H__

      再创建一个源文件test.c中放入主函数,主函数用于调用游戏模块的各个部分,再写一个简单的界面函数以便用户使用

    //test.c中的内容
    #include "game.h"
    void menu()//界面函数
    {
    printf("\n#################################\n");
    printf("##########  三子棋游戏  #########\n");
    printf("###########  1. 开始  ###########\n");
    printf("###########  0. 退出  ###########\n");
    printf("#################################\n");
    system("color e0");
    }
    
    int main()//主函数
    {
    int input = 0;
    srand((unsigned int)time(NULL));
    do
    {
    menu();
    scanf("%d",&input);
    switch(input)
    {
    case 1:
    game();
    break;
    case 0:
    printf("游戏已退出\n");
    break;
    default:
    printf("输入错误请重新输入\n");
    break;
    }
    }while(input);
    }

      接下来就是细节了game.c的内容(重头戏)
    首先初始化棋盘,想要下棋首先得有一个棋盘:(初始化不多说,大家都会)

    void Init_board(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++)
    {
       board[i][j] = ' ';
    }
    }
    }

    那么接下来就是把棋盘展示出来(不展示往哪下棋),给棋盘画出格子

    void Display_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++)
    {
    printf(" %c ",board[i][j]);
    if(j<col-1)
    printf("|");
    }
    printf("\n");
    if(i<row-1)
    {
    for(j=0; j<col; j++)
    {
    printf("---");
    if(j<col-1)
    printf("|");
    }
    printf("\n");
    }
    }
    }

    然后是用户下棋的过程

    void Player_move(char board[ROW][COL],int row,int col)//玩家走棋
    {
    int x = 0;
    int y = 0;
    while(1)
    {
    printf("玩家走棋(请输入坐标):\n");
    scanf("%d%d",&x,&y);//人落棋的坐标
    if(x>=1 && x<=row && y>=1 && y<=col)
    {
    if(board[x-1][y-1]==' ')//落棋的位置如果为空那么就将棋子下在此处
    {
       board[x-1][y-1] = '*';
    break;
    }
    else
    {
    printf("该位置已被占用,请重新输入\n");
    }
    }
    else
    {
    printf("输入位置错误,请重新输入\n");
    }
    }
    }

    接着是电脑走棋的过程

    void Computer_move(char board[ROW][COL],int row,int col)//电脑走棋
    {
    printf("电脑走棋:\n");
    while(1)
    {
    int x = rand()%3;
    int y = rand()%3;//设置随机数决定电脑落棋的位置
    if(x>=0 && x<row && y>=0 && y<col)
    {
    if(board[x][y] == ' ')//落棋的位置如果为空那么就将棋子下在此处
    {
        board[x][y] = 'o';
    break;
    }
    }
    }
    }

    当下出结果或者平局是我们需要一个函数来判断输赢或者平局

    char Is_win(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-1; j++)
    {
    if(board[i][j] != board[i][j+1])
    break;
    }
    if(j == col-1)
    {
    return board[i][0];
    }
    }
    //判断竖行是否有三个连棋
    for(i=0; i<row; i++)
    {
    for(j=0; j<col-1; j++)
    {
    if(board[j][i] != board[j+1][i])
    break;
    }
    if(j == col-1)
    {
    return board[j][i];
    }
    }
    //判断捺是否有三个连棋[0][0],[1][1],[2][2]
    for(i=0; i<row-1; i++)
     {
      if(board[i][i] != board[i+1][i+1])
      {
       break;
      }
     }
     if(i == row-1)
      {
       return board[i][i];
      }
    //判断撇是否有三个连棋[0][2],[1][1],[2][0]
    for(i=0; i<row-1; i++)
     {
      if(board[i][row-1-i] != board[i+1][row-1-i-1])
      {
       break;
      }
     }
     if(i == row-1)
      return board[0][row-1];
    if(Is_full(board,ROW,COL))
    return 'q';//返回q表示为平局
    else
    return ' ';
    }

    当棋谱满了时要么有人赢要么平局,所以我们还要判断一下棋盘满没满

    int Is_full(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++)
    {
    if(board[i][j] == ' ')
    return 0;//没满返回0
    }
    }
    return 1;//满了返回1
    }

    最后用一个game()函数来将上面的函数们联系起来

    void game()
    {
     char board[ROW][COL] = {0};
     char ret = 0;
     Init_board(board,ROW,COL);
     Display_board(board,ROW,COL);
     srand((unsigned int)time(NULL));
     while(1)
     {
      Computer_move(board,ROW,COL);//电脑先下
      ret = Is_win(board,ROW,COL);//判断这个时候有没有人赢
      {
       if(ret != ' ')
        break;
      }
      Display_board(board,ROW,COL);//展示这个时候的棋谱
      Player_move(board,ROW,COL);//人下棋
      ret = Is_win(board,ROW,COL);//判断这个时候有没有人赢
      {
       if(ret != ' ')
        break;
      }
      Display_board(board,ROW,COL);
     }
     {
      if(ret == '*')
      {
       printf("玩家赢\n");
      }
      else if(ret == 'o')
      {
       printf("电脑赢\n");
      }
      else if(ret == 'q')
      {
       printf("平局\n");
      }
      Display_board(board,ROW,COL);
     }
    }

    附上运行结果:
    在这里插入图片描述
    在这里插入图片描述
    颜色有点挫大家凑活看哈。

    总结

      三子棋到这里就结束了,没错,你竟然看懂了。一定要一步一步的分析要写的功能,然后一步一步实现,大事化小。


    PS:
      注意:一定要在自己的源文件中调用自己的头文件game.h,不然就会出错哟。
      然后就是大家有什么建议或者意见都可以提出来哟


    展开全文
  • C语言——扫雷游戏

    2018-05-29 14:23:54
    利用C语言学习到知识,就可以写一些简单的小游戏,比如:扫雷游戏。 在开始敲代码之前,需要如下准备: 一、 回顾一下怎么玩扫雷: 点击格子中任意一个位置,如果点到雷,那么就炸死,游戏结束,如果这个...
  • 很多计算机系毕业本科大学生,让他们去一个简单毕业设计管理系统,他们都是不出来。 因此,选择一个目标,自上而下去思考和学习,就非常重要了… 而编当时的小目标,做小项目——“贪吃蛇,.
  • C语言简单贪吃蛇学习

    千次阅读 2020-05-18 12:00:21
    刚刚学完C语言想着写个小项目巩固一下基础知识,为下一步学习打下坚实的基础,然后开始在各大网站博客寻找能做的项目,最终选择了贪吃蛇小游戏,大部分都是调用的库函数,没有用到链表,指针等较复杂的知识点。...
  • 我很喜欢玩游戏,不管是以前经典游戏,还是近年来3A级大作,每每在体验到它们优秀可玩性或者让人难以忘怀故事情节时,让我常常想,自己也能做一款这样令人满意的游戏, 这就是我想学好编程动力。...
  • 很早就想把自己的小游戏给大家分享一下(超简单),但是一直没有机会。 今天闲来无事,给大家伙们上道菜,代码也不是非常难。希望看完这篇文章小伙伴们,最后都能够自己写出来! 一、介绍 开发语言:C ...
  • 前言:C语言初学者都是在控制台上开发一些小游戏什么,由于没有界面(比如图片、音乐,不做出拥有自己风格程序)学起来比较乏味,很难坚持下去。所以我在这里就教大家使用简单的图形化工具——easyx图形界面库,...
  • C语言课程设以一节课,老师...界面很简单,没想到C语言能做这么有意思的东西,真是没有想到。分析一下程序,感觉比较太复杂的,但就是本学期学习的简单语句的组合,运用起来如此神奇。1、首先是在屏幕上显示的语句...
  • 第1节 zui快zui简单的排序——桶排序 2 第2节 邻居好说话——冒泡排序 7 第3节 zui常用排序——快速排序 12 第4节 哼买书 20 第2章 栈、队列、链表 25 第1节 解密QQ号——队列 26 第2节 解密回文——栈...
  • 网页小游戏

    2019-08-27 16:42:01
    利用HTML和JAVASCRIPT解决C语言模式下文本界面操作快速图形化转化。... ...小游戏</title> <head> </head> <body> <p>最简单的HTML文件!静态网页不交互,...
  • c语言编写单片机技巧

    2009-04-19 12:15:17
    答:对于复杂而开发时间紧项目时,可以采用C语言,但前提是要求对该MCU系统的C语言和C编译器非常熟悉,特别要注意该C编译系统所支持数据类型和算法。虽然C语言是最普遍一种高级语言,但不同MCU厂家其...
  • 明明喜欢玩游戏,而明明爸爸也乐意陪明明玩各种各样的小游戏。但是在游戏中,明明爸爸又十分注意培养明明智力,他希望通过游戏,不仅让明明得到快乐,而且又让明明学到一些知识,锻炼他思维能力,为将来...
  • 由来 最近人工智能很火,经常有...虽然最后不一定能做成什么,起码做的过程遇到问题解决问题,总能学会点什么。 那就从最简单的五子棋游戏开始好了,用普通的规则实现一个电脑下棋的算法,姑且叫做AI算法。作为一...
  • 火拼双扣 C语言

    2020-01-12 14:10:16
    由于小明打牌很差劲,所以他每次都是点提示出牌,而且小明是不会用连环炸弹,因为他觉得这样太浪费,现在就要你来完成简单的提示功能,我们提示功能简单到只要你输出有没有可能出牌,如果有可能出牌,输出“yes”...
  • 大一新生初体验——c语言实现贪吃蛇

    千次阅读 热门讨论 2021-01-17 14:22:16
    一个游戏当然不仅仅在黑框框实现,拥有一个自定义界面是一个良好开端 (1)首先需要改变黑框大小与颜色,我们可以运用initgraph与setbkcolor函数参数分别为(长,宽) (三原色比例),具体颜色可以调用...
  • 利用相关封装好函数,将其移植在了野火指南者开发板上,使其在触摸屏上显示,并且添加了暂停/继续触摸按键以及简单的游戏结束显示,大体再现了贪吃蛇这款小游戏。 一、主要功能 上图是整个显示屏布局以及...
  • 原标题:我们一起搭积木,做游戏,就这就简单如何写VBA代码,一直在有朋友向我询问这个问题,其实,写代码要有“搭积木”思想:首先要有大量资源,也就是积木原型,什么是积木呢?就是各自单独解决一个或几...
  • emmmm,说实在一开始C语言很无聊,但是童老师课很有意思,就跟着开始小游戏。作为一个测绘孩子,正在试图学好编程。 这是一个最简单的飞机游戏,可以控制飞机前有左右移动来消除靶子并且计分。靶子是伪...
  • 五子棋之类的游戏,非常简单,对于初学者来说是一个不错练手的小项目,以前用C语言写过三子棋游戏。最近在看C++,所以就想到在三子棋基础上利用C++语言实现五子棋游戏。 五子棋对局,执行黑方指定开局、三手...
  • 感谢:感谢 QQ 群 C语言革命7 全体成员为该项目开发了巨大贡献,没有你们,该作品也不有现在情况! 版权:作者原创,无抄袭,不涉及版权问题,仅用作学习、娱乐,欢迎各位fork! 玩法: 游戏开始选择系列...
  • 实训是在学生已经具备了使用C语言编写简单的应用程序能力,为使学生对C语言有更全面理解,进一步提高运用C语言编程解决实际问题能力,通过提出算法、指定输入输出来设计一个解决方案。并为参加计算机等级考试...
  • 本人是一名程序员,正好最近在课程设计,使用c语言配合easyx图形库(想下载图形库话百度搜索easyx就找到了)编写了一个五子棋的小游戏 去年课程设计,使用c语言配合easyx图形库(想下载话百度搜索就...
  • VC绘图 游戏简易教程

    2011-03-26 15:43:58
    能做简单的图形小游戏。  讲解以简单实用为主,不要指望看了这几篇文章后就能过二级考试。  目标,除了能做小游戏外,更重要,是锻炼编程思想,以备将来做更大程序。 学习方式  以自学为主吧,有问题就...
  • 第一个html5项目--五子棋

    千次阅读 2017-07-04 08:12:54
    html5代码更让人容易理解,代码简单轻松地100多行代码就做出一个小游戏。生活中我们常常玩一些游戏App都可以用html5来制作。html5还有超级炫酷3D效果,比一般平面小游戏更加立体,更加生动。例如切水果,...
  • 碰撞检测通常是游戏开发难点,作为引擎必然少不了碰撞检测部分,这里我们还是按照cocos2d构架,使用Box2d作为物理引擎,下面我们将通过在Ophone平台实现一个小游戏,来对Box2d物理引擎进行学习。  Box2d  ...

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

c语言能做的简单小游戏

c语言 订阅