精华内容
下载资源
问答
  • 非常强大的C语言 写的很多程序,带有注释,也含有几个C语言 小游戏,很棒
  • 主要为大家详细介绍了C语言实现简单五子棋小游戏,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 借用了一些《c语言课程设计与游戏开发》的素材以及参考了b站视频https://www.bilibili.com/video/BV1aK411V7HY?from=search&seid=18139813940740476300
  • Linux环境C语言实现2048小游戏,支持方向键控制,记录步数和相应得分
  • C语言制作小游戏——贪吃蛇

    千次阅读 2021-12-24 14:32:18
    C语言小游戏之贪吃蛇源代码

    直接上代码

    ​
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include <conio.h>
    #include <time.h>
    #include <windows.h>
     
    //MAXWIDTH、MAXHEIGHT、INITLEN 以字符记
    #define MAXWIDTH (30)
    #define MAXHEIGHT MAXWIDTH
    #define INITLEN (3)  //贪吃蛇的初始长度 
     
    //程序中用到的各种字符,以及它们的颜色和类型(以数字表示)
    struct{
        char *ch;
        int color;
        char type;
    }
    charBorder = {"□", 4, 1},  //边框
    charBg = {"■", 2, 2},  //背景
    charSnake = {"★", 0xe, 3},  //贪吃蛇节点
    charFood = {"●", 0xc, 4};  //食物
     
    //用一个结构体数组保存地图中的各个点
    struct{
        char type;
        int index;
    }globalMap[MAXWIDTH][MAXHEIGHT];
     
    //贪吃蛇有效活动范围地图的索引
    struct{
        int x;
        int y;
    } snakeMap[ (MAXWIDTH-2)*(MAXHEIGHT-2) ], scoresPostion;
     
    int scores = 0;  //得分
    int snakeMapLen = (MAXWIDTH-2)*(MAXHEIGHT-2);
    int headerIndex, tailIndex;  //蛇头蛇尾对应的snakeMap中的索引(下标)
    HANDLE hStdin;  //控制台句柄
     
    // 设置光标位置,x为行,y为列
    void setPosition(int x, int y){
        COORD coord;
        coord.X = 2*y;
        coord.Y = x;
        SetConsoleCursorPosition(hStdin, coord);
    }
     
    // 设置颜色
    void setColor(int color){
        SetConsoleTextAttribute(hStdin, color);
    }
     
    //创建食物
    void createFood(){
        int index, rang, x, y;
        //产生随机数,确定 snakeMap 数组的索引 
        srand((unsigned)time(NULL));
        if(tailIndex<headerIndex){
            rang = headerIndex-tailIndex-1;
            index = rand()%rang + tailIndex + 1;
        }else{
            rang = snakeMapLen - (tailIndex - headerIndex+1);
            index = rand()%rang;
            if(index>=headerIndex){
                index += (tailIndex-headerIndex+1);
            }
        }
         
        x = snakeMap[index].x;
        y = snakeMap[index].y;
        setPosition(x, y);
        setColor(charFood.color);
        printf("%s", charFood.ch);
        globalMap[x][y].type=charFood.type;
    }
     
    //死掉
    void die(){
        int xCenter = MAXHEIGHT%2==0 ? MAXHEIGHT/2 : MAXHEIGHT/2+1;
        int yCenter = MAXWIDTH%2==0 ? MAXWIDTH/2 : MAXWIDTH/2+1;
     
        setPosition(xCenter, yCenter-5);
        setColor(0xC);
     
        printf("You die! Game Over!");
        getch();
        exit(0);
    }
     
    // 蛇移动
    void move(char direction){
        int newHeaderX, newHeaderY;  //新蛇头的坐标
        int newHeaderPreIndex;  //新蛇头坐标以前对应的索引
        int newHeaderPreX, newHeaderPreY;  //新蛇头的索引以前对应的坐标
        int newHeaderPreType;  //新蛇头以前的类型
        int oldTailX, oldTailY;  //老蛇尾坐标
        // -----------------------------------------------
        //新蛇头的坐标
        switch(direction){
            case 'w':
                newHeaderX = snakeMap[headerIndex].x-1;
                newHeaderY = snakeMap[headerIndex].y;
                break;
            case 's':
                newHeaderX = snakeMap[headerIndex].x+1;
                newHeaderY = snakeMap[headerIndex].y;
                break;
            case 'a':
                newHeaderX = snakeMap[headerIndex].x;
                newHeaderY = snakeMap[headerIndex].y-1;
                break;
            case 'd':
                newHeaderX = snakeMap[headerIndex].x;
                newHeaderY = snakeMap[headerIndex].y+1;
                break;
        }
        //新蛇头的索引
        headerIndex = headerIndex==0 ? snakeMapLen-1 : headerIndex-1;
        // -----------------------------------------------
        //新蛇头坐标以前对应的索引
        newHeaderPreIndex = globalMap[newHeaderX][newHeaderY].index;
        //新蛇头的索引以前对应的坐标
        newHeaderPreX = snakeMap[headerIndex].x;
        newHeaderPreY = snakeMap[headerIndex].y;
     
        //双向绑定新蛇头索引与坐标的对应关系
        snakeMap[headerIndex].x = newHeaderX;
        snakeMap[headerIndex].y = newHeaderY;
        globalMap[newHeaderX][newHeaderY].index = headerIndex;
     
        //双向绑定以前的索引与坐标的对应关系
        snakeMap[newHeaderPreIndex].x = newHeaderPreX;
        snakeMap[newHeaderPreIndex].y = newHeaderPreY;
        globalMap[newHeaderPreX][newHeaderPreY].index = newHeaderPreIndex;
     
        //新蛇头以前的类型
        newHeaderPreType = globalMap[newHeaderX][newHeaderY].type;
        //设置新蛇头类型
        globalMap[newHeaderX][newHeaderY].type = charSnake.type;
        // 判断是否出界或撞到自己
        if(newHeaderPreType==charBorder.type || newHeaderPreType==charSnake.type ){
            die();
        }
        //输出新蛇头
        setPosition(newHeaderX, newHeaderY);
        setColor(charSnake.color);
        printf("%s", charSnake.ch);
        //判断是否吃到食物
        if(newHeaderPreType==charFood.type){  //吃到食物
            createFood();
            //更改分数
            setPosition(scoresPostion.x, scoresPostion.y);
            printf("%d", ++scores);
        }else{
            //老蛇尾坐标
            oldTailX = snakeMap[tailIndex].x;
            oldTailY = snakeMap[tailIndex].y;
            //删除蛇尾
            setPosition(oldTailX, oldTailY);
            setColor(charBg.color);
            printf("%s", charBg.ch);
            globalMap[oldTailX][oldTailY].type = charBg.type;
            tailIndex = (tailIndex==0) ? snakeMapLen-1 : tailIndex-1;
        }
    }
     
    //下次移动的方向
    char nextDirection(char ch, char directionOld){
        int sum = ch+directionOld;
        ch = tolower(ch);
        if( (ch=='w' || ch=='a' || ch=='s' || ch=='d') && sum!=197 && sum!=234 ){
            return ch;
        }else{
            return directionOld;
        }
    }
     
    //暂停
    char pause(){
        return getch();
    }
     
    // 初始化
    void init(){
        // 设置相关变量 
        int x, y, i, index;
        int xCenter = MAXHEIGHT%2==0 ? MAXHEIGHT/2 : MAXHEIGHT/2+1;
        int yCenter = MAXWIDTH%2==0 ? MAXWIDTH/2 : MAXWIDTH/2+1;
        CONSOLE_CURSOR_INFO cci;  //控制台光标信息
     
        //判断相关设置是否合理
        if(MAXWIDTH<16){
            printf("'MAXWIDTH' is too small!");
            getch();
            exit(0);
        }
     
        //设置窗口大小 
        system("mode con: cols=96 lines=32");
     
        //隐藏光标
        hStdin = GetStdHandle(STD_OUTPUT_HANDLE);
        GetConsoleCursorInfo(hStdin, &cci);
        cci.bVisible = 0;
        SetConsoleCursorInfo(hStdin, &cci);
         
        //打印背景 
        for(x=0; x<MAXHEIGHT; x++){
            for(y=0; y<MAXWIDTH; y++){
                if(y==0 || y==MAXWIDTH-1 || x==0 || x==MAXHEIGHT-1){
                    globalMap[x][y].type = charBorder.type;
                    setColor(charBorder.color);
                    printf("%s", charBorder.ch);
                }else{
                    index = (x-1)*(MAXWIDTH-2)+(y-1);
                    snakeMap[index].x= x;
                    snakeMap[index].y= y;
                    globalMap[x][y].type = charBg.type;
                    globalMap[x][y].index = index;
     
                    setColor(charBg.color);
                    printf("%s", charBg.ch);
                }
            }
            printf("\n");
        }
         
        //初始化贪吃蛇
        globalMap[xCenter][yCenter-1].type = globalMap[xCenter][yCenter].type = globalMap[xCenter][yCenter+1].type = charSnake.type;
     
        headerIndex = (xCenter-1)*(MAXWIDTH-2)+(yCenter-1) - 1;
        tailIndex = headerIndex+2;
        setPosition(xCenter, yCenter-1);
        setColor(charSnake.color);
        for(y = yCenter-1; y<=yCenter+1; y++){
            printf("%s", charSnake.ch);
        }
        //生成食物
        createFood();
     
        //设置程序信息
        setPosition(xCenter-1, MAXWIDTH+2);
        printf("   Apples : 0");
        setPosition(xCenter, MAXWIDTH+2);
        printf("   Author : xiao p");
        setPosition(xCenter+1, MAXWIDTH+2);
        printf("Copyright : c.biancheng.net");
        scoresPostion.x = xCenter-1;
        scoresPostion.y = MAXWIDTH+8;
    }
     
    int main(){
        char charInput, direction = 'a';
        init();
         
        charInput = tolower(getch());
        direction = nextDirection(charInput, direction);
     
        while(1){
            if(kbhit()){
                charInput = tolower(getch());
                if(charInput == ' '){
                    charInput = pause();
                }
                direction = nextDirection(charInput, direction);
            }
            move(direction);
            Sleep(500);
        }
         
        getch();
        return 0;
    }
    
    ​

    【操作过程】

    编译运行后,先按enter键使游戏开始,然后w,s a d 分别控制上下左右移动

    【运行展示】

     

    展开全文
  • C语言制作的课程设计小游戏,飞机大战。和团队一起设计并实现该游戏一方面巩固课堂学到的知识,学以致用,加深理论知识的理解,另一方面也锻炼了自己的实际编码能力和团队协作的能力,是一次难得又宝贵的实训开发...
  • 900行c语言实现扫雷小游戏,可实现随机放炸弹,自行设置炸弹数,传统扫雷玩法,键盘操作,图形界面,有初级高级两种模式。
  • C语言小游戏

    2011-12-14 16:47:06
    就是一个很新手的小游戏,初学者可以下来增加兴趣哦
  • C语言实现2048小游戏

    2018-06-29 00:18:06
    因为是在linux下写的,里面有5个文件,game2048为程序执行文件,game2048.c是主程序代码,keyboard.h是主程序里采用的键盘识别库,最后生成一个score_top.txt用来记录...基本实现2048小游戏的所有功能并能保存最高分
  • 贪吃蛇游戏源代码,codeblocks写的c语言小游戏源代码,可以运行。
  • C语言编程小游戏集锦

    热门讨论 2010-05-14 20:59:19
    该课题主要包括使用C语言制作 “贪吃蛇” “黑白棋”,主要考察对函数、结构体,指针,文件等的操作,以及C语言基本规则和算法的掌握,所以完成本课题能够培养较强的设计能力,特别是对C语言的综合应用能力。...
  • c语言迷宫小游戏.zip

    2021-05-11 08:09:30
    使用c语言制作的迷宫小游戏,图像界面使用的是easyx,游戏可以选择难度,有记录时间功能,暂停,刷新地图,可以通过拾取金币直接通关提示,同时设有排行榜。
  • C语言制作的推箱子小游戏带视频亲测游戏.rar
  • C语言实现俄罗斯方块小游戏制作代码,具体内容如下 #include #include #include <unistd> #define TTY_PATH /dev/tty #define STTY_ON stty raw -echo -F #define STTY_OFF stty -raw echo -F int map[21][14...
  • C语言文字小游戏制作

    2021-05-23 10:26:22
    你们想想,如果一个游戏游戏不能跟玩家交流是不是很无聊,一个劲输出让你像看故事一样。可能现在学了之后觉得没用,不过不用担心,学了就一定有用。你们都玩过游戏吧?不管手机游戏还是电脑游戏,都是一样的,就拿...

    scanf输入

    发布于2019-03-24 22:06

    嘿嘿,我又来了!

    上一章节中,我们说到了printf输出,既然有输出,当然也要有输入啦,对不对。

    今天我们要学的scanf输入函数!你们想想,如果一个游戏,游戏不能跟玩家交流是不是很无聊,一个劲输出让你像看故事一样。

    可能现在学了之后觉得没用,不过不用担心,学了就一定有用。你们都玩过游戏吧?不管手机游戏还是电脑游戏,都是一样的,就拿王者荣耀来说吧!

    当你进入游戏是不是要移动人物啊?这个移动就是输入,输入不同的信号,系统识别之后做出不同的动作输出到屏幕给我们看。

    是不是觉得很简单?

    首先我们在C4使用一下

    #include

    int main()

    {

    scanf("%s");

    return 0;

    }

    运行之后你会发现什么也没有,点一下屏幕然后就可以输入任意你想输入的文字,之前可是不能输入的哦!现在有了这条命令就ok了。

    我们来解释一下吧,scanf("%s");

    括号里面双引号包起来的是占位符,这个占位符代表的是字符串。就是说你输入的文字是字符串形式。 双引号包起来的也是字符串,在前面printf也讲过了。

    929f76f4997d6db6e6099a349cec73a0.png

    大概就先知道一下吧,后面会细说!因为我们还没学的变量判断什么的,所以基本用不上。😂

    (本章完)

    展开全文
  • C语言小游戏

    2018-03-22 14:46:14
    个人自主制作C语言小游戏
  • 四个c语言小游戏

    千次阅读 2021-11-22 19:37:41
    C语言小游戏0、前言1、普普通通的五子棋2、好难操作的贪吃蛇3、简单到炸的自制迷宫4、不忍直视的双人飞机对战 0、前言 1、我使用的是编译软件是vc6.0 2、如果代码无法运行,你可以尝试吧文件xxx.c改为xxx.cpp 3、四...

    0、前言

    1、我使用的是编译软件是vc6.0
    2、如果代码无法运行,你可以尝试吧文件xxx.c改为xxx.cpp
    3、四个小游戏我都运行过,确保是可以运行的。虽然可玩性、操作性。。。

    1、普普通通的五子棋

    这是四个游戏中,个人感觉最好的一个了。

    #include <stdio.h>
    #include <windows.h>
    #include <time.h>
    #include <conio.h>
    #include <stdlib.h>
    #define N 65
    
    int status[N][N]={{0},{0}};//记录棋盘情况,0无,1红棋/玩家,2为白棋/电脑 
    int flag=0;//判断输赢 
    int direct[2];//方向
    int Value1[N][N]={{0},{0}};//计算权值 
    int Value2[N][N]={{0},{0}};//计算权值
    int regrex,regrey,regrex1,regrey1; 
    int count=0;//计算棋子数量 
    
    void chess_board();//打印棋盘 
    void red_movexy();//红子棋移动光标
    void white_movexy();//白棋移动光标 
    void red_chess(int x,int y);//红棋
    void white_chess(int x,int y);//白棋
    void man_man();
    void man_machine();//人机对战
    int judge_chess(int x,int y);//判断这个位置是否下过 
    int judge_winner(int x,int y,int temp);//判断输赢 
    void machine_attack();//电脑进攻权值 
    void machine_defend();//电脑防守权值 
    void find_position();//寻找最佳权值
    void Regret();//悔棋函数 
    
    void BackGround(unsigned int ForeColor, unsigned int BackGroundColor)  //颜色 
    {
    	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);  //获取控制台的句柄
    	SetConsoleTextAttribute(handle, ForeColor + BackGroundColor * 0x10);//改变当前光标的背景和字体颜色
    }
    
    void gotoxy(int x, int y)    //光标函数 
    {
    	HANDLE handle;
    	COORD coord;   //获取坐标轴结构体
    	coord.X = x;
    	coord.Y = y;
    	handle = GetStdHandle(STD_OUTPUT_HANDLE);  //获取控制台句柄,值为-11
    	SetConsoleCursorPosition(handle, coord);   //移动光标到x,y处
    }
    
    void chess_board()//打印棋盘 
    {
    	int i,j;
    	for(i=0;i<=30;i++)
    	    for(j=0;j<=60;j+=4)
    	    {
    	    	gotoxy(j,i);
    	    	printf("|");
    		}
    	for(i=0;i<=30;i+=2)
    	    for(j=1;j<=57;j+=4)
    	    {
    	    	gotoxy(j,i);
    	    	printf("---");
    		}
    }
    
    void chess_menu()//打印棋盘旁的菜单 
    {
    	int i,j;
    	for(i=1;i<=29;i++)
    	{
    		gotoxy(67,i);
    		printf("||");
    	}
    	for(i=1;i<=29;i++)
    	{
    		gotoxy(89,i);
    		printf("||");
    	}
    	gotoxy(69,1);
    	printf("--------------------");
    	gotoxy(69,29);
    	printf("--------------------");
    	gotoxy(75,3);
    	printf("模   式");
    	gotoxy(75,20);
    	printf("提   示");
    }
    
    void red_movexy()//红棋移动光标 
    {
    	loop2:gotoxy(direct[0],direct[1]);
    	char key='y';
    	int temp;
    	while(key!=' ')
    	{
    	    key=getch();
    		switch(key)
    		{
    			case 'W':
        		case 'w':
    	    		direct[1]-=2;
    	    		if(direct[1]<=1)
    	    		    direct[1]=1;
        			break;
        		case 's':
        		case 'S':
        			direct[1]+=2;
    	    		if(direct[1]>=29)
    	    		    direct[1]=29;
        			break;
        		case 'a':
        		case 'A':
    	    		direct[0]-=4;
    	    		if(direct[0]<=2)
    	    		    direct[0]=2;
    	    		break;
        		case 'd':
        		case 'D':
    	    		direct[0]+=4;
    	    		if(direct[0]>=58)
    	    		    direct[0]=58;
        			break;
        		case 'q':
        		case 'Q':
        		{ 
    				int message=MessageBox(NULL,"是否确定悔棋?","友情提示",MB_OKCANCEL);
    		        if(IDCANCEL==message)
    					break;
    			    if(IDOK==message)
    			    {
    			    	Regret();
        				break;
        			}
        		}
        	}
        	gotoxy(direct[0],direct[1]);
        }
            temp=judge_chess(direct[1],direct[0]);
    	    if(temp==1)
    	    {
    	    	gotoxy(70,22);
    	    		BackGround(4, 0);
    				printf("这里已经被人下过了");
    			goto loop2;
    		}
    }
    
    void white_movexy()//白棋移动光标 
    {
    	loop1:gotoxy(direct[0],direct[1]);
    	char key='y';
    	int temp;
    	while(key!='0')
    	{
    	    key=getch();
    		switch(key)
    		{
        		case 72:
    	    		direct[1]-=2;
    	    		if(direct[1]<=1)
    	    		    direct[1]=1;
        			break;
        		case 80:
        			direct[1]+=2;
    	    		if(direct[1]>=29)
    	    		    direct[1]=29;
        			break;
        		case 75:
    	    		direct[0]-=4;
    	    		if(direct[0]<=2)
    	    		    direct[0]=2;
    	    		break;
        		case 77:
    	    		direct[0]+=4;
    	    		if(direct[0]>=58)
    	    		    direct[0]=58;
        			break;
        		case 'B':
        		case 'b':
        		{ 
    				int message=MessageBox(NULL,"是否确定悔棋?","友情提示",MB_OKCANCEL);
    		        if(IDCANCEL==message)
    					break;
    			    if(IDOK==message)
    			    {
    			    	Regret();
        				break;
        			}
        		}
        	}
        	gotoxy(direct[0],direct[1]);
        }
            temp=judge_chess(direct[1],direct[0]);
    	    if(temp==1)
    	    {
    	    	gotoxy(70,22);
    	    		BackGround(4, 0);
    				printf("这里已经被人下过了");
    			goto loop1;
    		}
    }
    
    void red_chess(int x,int y)//打印红棋 
    {
    	BackGround(4,0);
    	regrex=x;//记录上一落子的位置 ,方便悔棋 
    	regrey=y;
    	count++;
    	printf("●");
    	status[x][y]=1;
    }
    
    void white_chess(int x,int y)//打印白棋
    {
    	BackGround(7,0);
    	regrex1=x;
    	regrey1=y;
    	printf("●");
    	count++;
    	status[x][y]=2;
    }
    
    void machine_chess(int x,int y)//电脑落子
    {
    	BackGround(7,0);
    	status[x][y]=2;
    	regrex1=x;
    	regrey1=y;
    	count++;
    	gotoxy(y,x);
    	printf("●");
    }
    
    int judge_chess(int x,int y)//判断这个地方是否有棋子
    {
    	if(status[x][y]==0)
    		return 0;
    	else
    		return 1;
    } 
    
    int judge_winner(int x,int y,int temp)//判断输赢 
    { 
    	int i,j,n1,n2;
    	n1=n2=0;
    	for(i=x,j=y+4;j<=58;j+=4)//右
    	{
    		if(status[i][j]==temp)
    		    n1++;
    		else
    		    break;
    	}
    	for(i=x,j=y;j>=2;j-=4)//左
    	{
    		if(status[i][j]==temp)
    		    n2++;
    		else
    		    break;
    	}
    	if(n1+n2>=5)
    	    return temp;
    	n1=n2=0;
    	for(i=x,j=y;i>=1;i-=2)//上 
    	{
    		if(status[i][j]==temp)
    		    n1++;
    		else
    		    break;
    	}
    	for(i=x+2,j=y;i<=30;i+=2)//下 
    	{
    		if(status[i][j]==temp)
    		    n2++;
    		else
    		    break;
    	}
    	if(n1+n2>=5)
    	    return temp;
    	n1=n2=0;
    	for(i=x-2,j=y+4;i>=1&&j<=58;i-=2,j+=4)//右上 
    	{
    		if(status[i][j]==temp)
    		    n1++; 
    		else
    		    break;
    	}
    	for(i=x,j=y;i<=30&&j>=2;i+=2,j-=4)//左下
    	{
    		if(status[i][j]==temp)
    		    n2++; 
    		else
    		    break;
    	}
    	if(n1+n2>=5)
    	    return temp;
    	n1=n2=0;
    	for(i=x,j=y;i>=0&&j>=0;i-=2,j-=4)//左上 
    	{
    		if(status[i][j]==temp)
    		    n1++; 
    		else
    		    break;
    	}
    	for(i=x+2,j=y+4;i<=30&&j<=58;i+=2,j+=4)//右下
    	{
    		if(status[i][j]==temp)
    		    n2++; 
    		else
    		    break;
    	}
    	if(n1+n2>=5)
    	    return temp;
    	return 0;
    }
    
    void machine_attack()//电脑进攻权值 
    {
    	int i1,j1;
    	int k1,k2,k;
    	for(int i=1;i<=30;i+=2)
    	{
    		for(int j=2;j<=58;j+=4)
    		{
    			if(status[i][j])
    				Value1[i][j]=0;
    			if(status[i][j]==0)
    			{
    				k1=k2=0;
    				for(i1=i,j1=j-4;j1>=2;j1-=4)//往左数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i,j1=j+4;j1<=58;j1+=4)//往右数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k2++;
    					else
    						break;
    				}
    				k=k1>k2? k1:k2;
    				k1=k2=0;
    				for(i1=i-2,j1=j;i1>=1;i1-=2)//往上数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i+2,j1=j;i1<=30;i1+=2)//往下数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k2++;
    					else
    						break;
    				}
    				k1=k1>k2? k1:k2;
    				k=k>k1? k:k1;
    				k1=k2=0;
    				for(i1=i-2,j1=j-4;i1>=0&&j1>=0;i1-=2,j1-=4)//往左上数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i+2,j1=j+4;i1<=30&&j1<=58;i1+=2,j1+=4)//往右下数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2 )
    						k2++;
    					else
    						break;
    				}
    				k1=k1>k2? k1:k2;
    				k=k>k1?k:k1;
    				k1=k2=0;
    				for(i1=i+2,j1=j-4;i1<=30&&j1>=2;i1+=2,j1-=4)//往左下数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i-2,j1=j+4;i1>=1&&j1<=58;i1-=2,j1+=4)//往右上数寻找电脑棋子数
    				{
    					if(status[i1][j1]==2)
    						k2++;
    					else
    						break;
    				}
    				k1=k1>k2? k1:k2;
    				k=k>k1?k:k1;
    				switch(k) 
    				{ 
    					case 3:
    						Value1[i][j]=15;break;                       
    					case 4:
    						Value1[i][j]=25;break; 
    					default:
    						Value1[i][j]=3+2*k;break;
    				}
    			}
    		}
    	}
    }
    
    void machine_defend()//防守权值
    {
    	int i1, j1;
    	int k1,k2,k;
    	for(int i=1;i<=30;i+=2)
    	{
    		for(int j=2;j<=58;j+=4)
    		{
    			if(status[i][j])
    				Value2[i][j]=0;
    			if(status[i][j]==0)
    			{
    				k1=k2=0;
    				for(i1=i,j1=j-4;j1>=2;j1-=4)//往左数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i,j1=j+4;j1<=58;j1+=4)//往右数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k2++; 
    					else
    						break;
    				}
    				k=k1>k2? k1:k2;
    				k1=k2=0;
    				for(i1=i-2,j1=j;i1>=1;i1-=2)//往上数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i+2,j1=j;i1<=30;i1+=2)//往下数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k2++;
    					else
    						break;
    				}
    				k1=k1>k2? k1:k2;
    				k=k>k1?k:k1;
    				k1=k2=0;
    				for(i1=i-2,j1=j-4;i1>=1&&j1>=2;i1-=2,j1-=4)//往左上数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i+2,j1=j+4;i1<=30&&j1<=58;i1+=2,j1+=4)//往右下数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k2++;
    					else
    						break;
    				}
    				k1=k1>k2? k1:k2;
    				k=k>k1?k:k1;
    				k1=k2=0;
    				for(i1=i+2,j1=j-4;i1<=30&&j1>=2;i1+=2,j1-=4)//往左下数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k1++;
    					else
    						break;
    				}
    				for(i1=i-2,j1=j+4;i1>=1&&j1<=58;i1-=2,j1+=4)//往右上数寻找玩家棋子数
    				{
    					if(status[i1][j1]==1)
    						k2++;
    					else
    						break;
    				}
    				k1=k1>k2? k1:k2;
    				k=k>k1?k:k1;
    			    switch(k)
    				{
    					case 3:
    						Value2[i][j]=10;break;                 
    					case 4:                                       
    						Value2[i][j]=20;break;
    					default:
    						Value2[i][j]=2+k*2;
    				}
    			}
    		}
    	}
    }
    
    void find_position()//找到最有价值的位置
    {
    	int k1=0, k2=0;
    	int i, j, max=0;
    	for( i=1;i<=30;i+=2)
    		for( j=2;j<=58;j+=4)
    		{
    			if(max<=Value1[i][j])
    			{
    				max=Value1[i][j];
    				k1=i;
    				k2=j;
    			}
    		}
    	for( i=1;i<=30;i+=2)
    		for( j=2;j<=58;j+=4)
    		{
    			if(max<=Value2[i][j])
    			{
    				max=Value2[i][j];
    				k1=i;
    				k2=j;
    			}
    		}
    	direct[1]=k1;  //将找到的位置传给光标
    	direct[0]=k2;
    }
    
    void man_man()//人人对战模式
    {
    	loop5:system("cls");
    	char key;
    	int control;
    	gotoxy(2, 3);
    	printf("1.红 子 先 手");
    	
    	gotoxy(2, 5);
    	printf("2.白 子 先 手");
    	
    	gotoxy(2, 7);
    	printf("(输入相应序号选择)");
    	key=getch();
    	system("cls");
    	if(key=='1')
    		control=1;
    	else if(key=='2')
    		control=-1;
    	else
    		goto loop5;
    	gotoxy(70,5);
    	printf("   人 人 对 战    "); 
    	direct[1]=15;
    	direct[0]=30;
    	chess_board();
    	chess_menu();
    	while(flag==0)
    	{
    		if(control==1)
    		{
    			gotoxy(70,22);
    			BackGround(6,0);
    			printf("   红 子 执 手    "); 
    			red_movexy();
    			red_chess(direct[1],direct[0]);
    			flag=judge_winner(direct[1],direct[0],1);
    		}
    		else
    		{
    			gotoxy(70,22);
    			BackGround(6,0);
    			printf("   白 子 执 手    "); 
    			white_movexy();
    			white_chess(direct[1],direct[0]);
    			flag=judge_winner(direct[1],direct[0],2);
    		}
    		control=-control;
    	}
    	if(flag==1)
    	{
    		BackGround(7,0);
    		MessageBox(NULL,"游戏结束,红子胜利","五子棋游戏",MB_OK);
    	}
    	if(flag==2)
    	{
    		MessageBox(NULL,"游戏结束,白子胜利","五子棋游戏",MB_OK);
    	}
    	if(count>=225)
    	{
    		MessageBox(NULL,"游戏结束,平局","五子棋游戏",MB_OK);
    	}
    }
    
    void man_machine()//人机对战模式 
    {
    	loop6:system("cls");
    	char key;
    	int control;
    	gotoxy(2, 3);
    	printf("1.玩 家 先 手(玩家为红子)");
    	
    	gotoxy(2, 5);
    	printf("2.电 脑 先 手(电脑为白子)");
    	
    	gotoxy(2, 7);
    	printf("(输入相应序号选择)");
    	key=getch();
    	system("cls");
    	if(key=='1')
    		control=1;
    	else if(key=='2')
    	{
    		control=1;
    		machine_chess(13,26);
    	}
    	else 
    		goto loop6;
    	gotoxy(70,5);
    	printf("   人 机 对 战    ");
    	direct[1]=15;
    	direct[0]=30;
    	chess_board();
    	chess_menu();
    	while(flag==0)
    	{
    		if(control==1)
    		{
    			gotoxy(70,22);
    			BackGround(6,0);
    			printf("   玩 家 执 手    "); 
    			red_movexy();
    			red_chess(direct[1],direct[0]);
    			flag=judge_winner(direct[1],direct[0],1);
    		}
    		else
    		{
    			gotoxy(70,22);
    			BackGround(6,0);
    			printf("   电 脑 执 手    "); 
    			machine_defend();
    			machine_attack();
    			find_position();
    			machine_chess(direct[1],direct[0]);
    			flag=judge_winner(direct[1],direct[0],2);
    		}
    		control=-control;
    	}
    	gotoxy(8,18);
    	if(flag==1)
    	{
    		BackGround(7,0);
    		MessageBox(NULL,"太厉害了,您竟然战胜了电脑!","五子棋游戏",MB_OK);
    	}
    	if(flag==2)
    	{
    		MessageBox(NULL,"游戏结束,您输给了电脑","五子棋游戏",MB_OK);
    	}
    	if(count>=225)
    	{
    		MessageBox(NULL,"平局","五子棋游戏",MB_OK);
    	}
    }
    
    void Regret()//悔棋函数 
    {
    	gotoxy(regrey,regrex);
    	BackGround(0,0);
     	printf(" ");
    	status[regrex][regrey]=0;
    	gotoxy(regrey1,regrex1);
    	BackGround(0,0);
     	printf(" ");
    	status[regrex1][regrey1]=0;
    	count-=2;
    } 
    
    void welcome()//游戏菜单 
    {
    	int k;
    	char choose;
    	system("cls");
    	for(k=2;k<=16;k+=2)//游戏菜单 
    	{
    		gotoxy(5,k);	
        	printf("|-----------------|");
    	}
    	gotoxy(5, 3);
    	printf("|  五 子 棋 游 戏 |");
    	
    	gotoxy(5, 5);
    	printf("|     菜    单    |");
    
    	gotoxy(5, 7);
    	printf("|  1.人 人 对 战  |");
    	
    	gotoxy(5, 9);
    	printf("|  2.人 机 对 战  |");
    	
    	gotoxy(5, 11);	
    	printf("|  3.游 戏 帮 助  |");
    	
    	gotoxy(5, 13);	
    	printf("|  4.更 新 日 志  |");
    	
    	gotoxy(5, 15);
    	printf("|  5.退 出 游 戏  |");
    	
    	gotoxy(5, 18);
    	printf("温馨提示:输入菜单对应序号进行操作");
    	
    	gotoxy(5, 20);
    	printf("祝您游戏愉快!");
    	
    	gotoxy(13, 20);
    }
    
    char Gametips()//游戏帮助 
    {
    	char choose;
    	int key;
    	
    	system("cls");
    	
    	gotoxy(2, 3);
    	printf("游戏操作:"); 
    		
    	gotoxy(4, 5);
    	printf("① 红色棋子WASD移动光标选择下棋位置,按空格键确认,按Q悔棋"); 
    		
    	gotoxy(4, 7);
    	printf("② 白色棋子↑↓←→移动光标选择下棋位置,按0确认,按B悔棋");
    		
    	gotoxy(2, 19);
    	printf("(按任意键返回)");
    	
    	return getch();
    }
    
    char Updatediary()//更新日志 
    {
    	system("cls");
    	
    	gotoxy(2, 3);
    	printf("(暂时没有)"); 
    	
    	gotoxy(2, 5);
    	printf("(按任意键返回)");
    	
    	return getch();
    }
    
    int main()
    {
    	system("title 五子棋");
    	system("mode con cols=92 lines=33");
    	char choose,temp;
    thetop:	loop:welcome();
    	choose=getch();
    	switch(choose)
    	{
    		case '1':
    			man_man();
    			goto thetop;
    			break;
    		case '2':
    			man_machine();
    			goto thetop;
    			break;
    		case '3':
    			temp=Gametips();
    				goto thetop;
    			break;
    		case '4':
    			temp=Updatediary();
    				goto thetop;
    			break;
    		case '5':
    			int message=MessageBox(NULL,"是否退出?","友情提示",MB_OKCANCEL);
    			if(IDCANCEL==message)
    				goto thetop;
    			if(IDOK==message)
    			{
    				break;
    			}
    	}
    }
    
    

    2、好难操作的贪吃蛇

    贪吃蛇的基本框架还是有的。

    文件一:stdafx.h

    #if !defined(AFX_STDAFX_H__20B660F3_64B9_4993_8071_269F806FAF71__INCLUDED_)
    #define AFX_STDAFX_H__20B660F3_64B9_4993_8071_269F806FAF71__INCLUDED_
    
    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000
    
    

    代码二:主程序

    #include "stdafx.h"
    /*******头  文  件*******/
    #include<stdio.h>			//标准输入输出函数库
    #include<time.h>			//用于获得随机数
    #include<windows.h>			//控制dos界面
    #include<stdlib.h>			//即standard library标志库头文件,里面定义了一些宏和通用工具函数
    #include<conio.h>			//接收键盘输入输出
    
    /*******宏  定  义*******/
    #define U 1
    #define D 2
    #define L 3 
    #define R 4    //蛇的状态,U:上 ;D:下;L:左 R:右
    
    /*******定  义  全  局  变  量 *******/
    typedef struct snake 		//蛇身的一个节点
    {
        int x;					//节点x坐标
        int y;					//节点y坐标
        struct snake *next;		//蛇身体下一节点
    }snake;
    int score=0;                //总得分
    int add=10;			        //每次吃食物得分
    int HighScore = 0;			//最高分
    int status;					//蛇前进状态
    int sleeptime=200;			//每次运行的时间间隔
    snake *head;				//蛇头指针
    snake *food;				//食物指针
    snake *q;					//遍历蛇的时候用到的指针
    int endgamestatus=0;		//游戏结束的情况,1:撞到墙;2:咬到自己;3:主动退出游戏
    HANDLE hOut;				//控制台句柄
    
    /*******函  数  声  明 *******/
    void gotoxy(int x,int y);   //设置光标位置
    int color(int c);           //更改文字颜色
    void printsnake();          //字符画
    void welcometogame();       //开始界面
    void createMap();           //绘制地图
    void scoreandtips();		//游戏界面右侧的得分和小提示
    void initsnake();           //初始化蛇身,画蛇身
    void createfood();          //创建并随机出现食物
    int biteself();             //判断是否咬到了自己
    void cantcrosswall();       //设置蛇撞墙的情况
    void speedup();				//加速
    void speeddown();			//减速
    void snakemove();           //控制蛇前进方向
    void keyboardControl();     //控制键盘按键
    void Lostdraw();            //游戏结束界面
    void endgame();             //游戏结束
    void choose();				//游戏失败之后的选择
    void File_out();            //在文件中读取最高分
    void File_in();            	//储存最高分进文件
    void explation();           //游戏说明
    
    /*
    	设置光标位置
    */
    void gotoxy(int x,int y)
    {
        COORD c;
        c.X=x;
        c.Y=y;
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),c);
    }
    
    /*
    	文字颜色函数
    */
    int color(int c)
    {
    	//SetConsoleTextAttribute是API设置控制台窗口字体颜色和背景色的函数
    	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c);        //更改文字颜色
    	return 0;
    }
    
    /*
    	字符拼成英文图案
    */
    void printsnake()
    {
    	color(2);
    	printf("                                                                                         \n");
    	printf("                       __________       ___                                              \n");
    	printf("                      /          \\     / \\ \\    |____      __\\__                     \n");
    	printf("                     /  ________  \\   / ___ \\  _/ __     | |   /                       \n");
    	printf("                     |  |      |__|     _/_   |_|  /    [|] |/                           \n");
    	printf("                     |  |              | | |      /     _|_ \\__/                        \n");
    	printf("                     \\  \\_______        / \\      |___/        ____                    \n");
    	printf("                      \\         \\    ____ ____      ____   __ |  |  ___   ______       \n");
    	printf("                       \\_______  \\   |  |/    \\    /    \\_/ / |  | /  /  /      \\   \n");
    	printf("                               \\  \\  |    ___  \\  / ____   /  |  |/  /  /  ____  \\   \n");
    	printf("                     __        |  |  |   /   \\  \\ | |  |  /   |     /  |  /____\\  |   \n");
    	printf("                    \\  \\_______|  |  |  |    |  | | |__|  |   |     \\  |  ________/   \n");
    	printf("                     \\            /  |  |    |  |  \\       \\  |  |\\  \\  \\  \\____  \n");
    	printf("                      \\__________/   |__|    |__|   \\___/\\__\\ |__| \\__\\  \\______/ \n");
    	 
    
    
    
    	
    }
    
    /*
    	开始界面
    */
    void welcometogame()
    {
    	int n;
    	int i,j = 1;
    	gotoxy(43,18);
    	color(11);
    	printf("贪 吃 蛇 游 戏");
    	color(14);          			//黄色边框
    	for (i = 20; i <= 26; i++)   	//输出上下边框┅
    	{
    		for (j = 27; j <= 74; j++)  //输出左右边框┇
    		{
    			gotoxy(j, i);
    			if (i == 20 || i == 26)
    			{
    				printf("-");
                }
    			else if (j == 27 || j == 74)
                {
    				printf("|");
                }
    		}
    	}
    	color(10);
    	gotoxy(35, 22);
    	printf("1.开始游戏");
    	gotoxy(55, 22);
    	printf("2.游戏说明");
    	gotoxy(35, 24);
    	printf("3.退出游戏");
    	gotoxy(29,27);
    	color(3);
    	printf("请选择[1 2 3]:[ ]\b\b");        //\b为退格,使得光标处于[]中间
    	color(14);
        scanf("%d", &n);    		//输入选项
        switch (n)
        {
        	case 1:					//选择开始游戏
        		system("cls");
    			createMap();        //创建地图
    			initsnake();        //初始化蛇身
    			createfood();		//初始化食物
    			keyboardControl();	//控制键盘按钮
            	break;
        	case 2:					//选择游戏说明
            	explation();
            	break;
        	case 3:					//选择退出游戏
            	exit(0);     		//退出游戏
            	break;
    		default:				//输入非1~3之间的选项
    			color(12);
    			gotoxy(40,28);
    			printf("请输入1~3之间的数!");
    			getch();			//输入任意键
    			system("cls");		//清屏
    			printsnake();
    			welcometogame();
        }
    }
    
    /*
    	创建地图
    */
    void createMap()
    {
        int i,j;
        for(i=0;i<58;i+=2)		//打印上下边框
        {
            gotoxy(i,0);
    		color(6);			//深绿色的边框
            printf("□");
            gotoxy(i,26);
            printf("□");
        }
        for(i=1;i<26;i++)		//打印左右边框
        {
            gotoxy(0,i);
            printf("□");                        
            gotoxy(56,i);
            printf("□");        
        }
    	for(i = 2;i<56;i+=2)	//打印中间网格
    	{
    		for(j = 1;j<26;j++)
    		{
    			gotoxy(i,j);
    			color(3);
    			printf("■\n\n");
    		}
    	}
    }
    
    /*
    	游戏界面右侧的得分和小提示
    */
    void scoreandtips()
    {
    	File_out();				//调用File_out(),读取文件save.txt中的内容
    	gotoxy(64,4);			//确定打印输出的位置
    	color(11);				//设置颜色
    	printf("☆最高记录☆:%d",HighScore);	//打印最高分
    	gotoxy(64,8);
    	color(14);
    	printf("当前得分:%d  ",score);
    	color(15);
    	gotoxy(73,11);
    	printf("小 提 示");
    	gotoxy(60,13);
    	color(6);
    	printf("╬ ┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅ ╬");
    	gotoxy(60,25);
    	printf("╬ ┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅ ╬");
    	color(3);
    	gotoxy(64,14);
    	printf("每个食物得分:%d分",add);
    	gotoxy(64,16);
    	printf("不能撞墙,不能咬到自己");
    	gotoxy(64,18);
    	printf("用↑ ↓ ← →分别控制蛇的移动");
    	gotoxy(64,20);
    	printf("F1键加速,F2键减速");
    	gotoxy(64,22);
    	printf("空格键暂停游戏");
    	gotoxy(64,24);
        printf("Esc键退出游戏");
    }
    
    /*
    	初始化蛇身,画蛇身
    */
    void initsnake()
    {
        snake *tail;
        int i;
        tail=(snake*)malloc(sizeof(snake));	//从蛇尾开始,头插法,以x,y设定开始的位置
        tail->x=24;				//蛇的初始位置(24,5)
        tail->y=5;
        tail->next=NULL;
        for(i=1;i<=4;i++)       //设置蛇身,长度为5
        {
            head=(snake*)malloc(sizeof(snake)); //初始化蛇头
            head->next=tail;    //蛇头的下一位为蛇尾
            head->x=24+2*i;     //设置蛇头位置
            head->y=5;
            tail=head;          //蛇头变成蛇尾,然后重复循环
        }
        while(tail!=NULL)		//从头到尾,输出蛇身
        {
            gotoxy(tail->x,tail->y);
    		color(14);
            printf("◆");       //输出蛇身,蛇身使用◆组成
            tail=tail->next;    //蛇头输出完毕,输出蛇头的下一位,一直输出到蛇尾
        }
    }
    
    /*
    	随机出现食物
    */
    void createfood()
    {
        snake *food_1;
        srand((unsigned)time(NULL));        	//初始化随机数
        food_1=(snake*)malloc(sizeof(snake));   //初始化food_1
        while((food_1->x%2)!=0)    				//保证其为偶数,使得食物能与蛇头对齐,然后食物会出现在网格线上
        {
            food_1->x=rand()%52+2;              //食物随机出现,食物的x坐标在2~53
        }
        food_1->y=rand()%24+1;					//食物的y坐标在1~24
        q=head;
        while(q->next==NULL)
        {
            if(q->x==food_1->x && q->y==food_1->y) //判断蛇身是否与食物重合
            {
                free(food_1);               //如果蛇身和食物重合,那么释放食物指针
                createfood();               //重新创建食物
            }
            q=q->next;
        }
        gotoxy(food_1->x,food_1->y);
        food=food_1;
    	color(12);
        printf("●");           //输出食物
    }
    
    /*
    	判断是否咬到了自己
    */
    int biteself()
    {
        snake *self;            //定义self为蛇身上的一个节点
        self=head->next;        //self是蛇头之外的蛇身上的节点
        while(self!=NULL)
        {
            if(self->x==head->x && self->y==head->y)    //如果self和蛇身上的节点重合
            {
                return 1;       //返回1
            }
            self=self->next;
        }
        return 0;
    }
    
    /*
    	设置蛇撞墙的情况
    */
    void cantcrosswall()
    {  
        if(head->x==0 || head->x==56 ||head->y==0 || head->y==26) //如果蛇头碰到了墙壁
        {
            endgamestatus=1;        //返回第一种情况
            endgame();              //出现游戏结束界面
        }
    }
    
    /*
    	加速,蛇吃到食物会自动提速,并且按F1会加速
    */
    void speedup()
    {
    	if(sleeptime>=50)
    	{
    		sleeptime=sleeptime-10;
    		add=add+2;
    
        }
    }
    
    /*
    	减速,按F2会减速
    */
    void speeddown()
    {
    	if(sleeptime<350)               //如果时间间隔小于350
        {
            sleeptime=sleeptime+30;     //时间间隔加上30
            add=add-2;                  //每吃一次食物的得分减2
    
        }
    }
    
    /*
    	控制方向
    */
    void snakemove()	//蛇前进,上U,下D,左L,右R
    {
    	snake * nexthead;
        cantcrosswall();
        nexthead=(snake*)malloc(sizeof(snake));		//为下一步开辟空间
        if(status==U)
        {
            nexthead->x=head->x;        //向上前进时,x坐标不动,y坐标-1
            nexthead->y=head->y-1;
            nexthead->next=head;
            head=nexthead;
            q=head;						//指针q指向蛇头
            if(nexthead->x==food->x && nexthead->y==food->y)	//如果下一个有食物 下一个位置的坐标和食物的坐标相同
            {
                
                while(q!=NULL)
                {
                    gotoxy(q->x,q->y);
    				color(14);
                    printf("◆");       //原来食物的位置,从●换成◆
                    q=q->next;          //指针q指向的蛇身的下一位也执行循环里的操作
    				
                }
                score=score+add;        //吃了一个食物,在总分上加上食物的分
    			speedup();
                createfood();           //创建食物
            }
            else                        
            {
                while(q->next->next!=NULL)	//如果没遇到食物
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");           //蛇正常往前走,输出当前位置的蛇身
                    q=q->next;              //继续输出整个蛇身
                }
                gotoxy(q->next->x,q->next->y);  //经过上面的循环,q指向蛇尾,蛇尾的下一位,就是蛇走过去的位置
    			color(3);
                printf("■");
                free(q->next);			//进行输出■之后,释放指向下一位的指针
                q->next=NULL;			//指针下一位指向空
            }
        }
        if(status==D)
        {
            nexthead->x=head->x;        //向下前进时,x坐标不动,y坐标+1
            nexthead->y=head->y+1;
            nexthead->next=head;
            head=nexthead;
            q=head;
            if(nexthead->x==food->x && nexthead->y==food->y)  //有食物
            {
                
                while(q!=NULL)
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");
                    q=q->next;
                }
                score=score+add;
    			speedup();
                createfood();
            }
            else                               //没有食物
            {
                while(q->next->next!=NULL)
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");
                    q=q->next;
                }
                gotoxy(q->next->x,q->next->y);
    			color(3);
                printf("■");
                free(q->next);
                q->next=NULL;
            }
        }
        if(status==L)
        {
            nexthead->x=head->x-2;        //向左前进时,x坐标向左移动-2,y坐标不动
            nexthead->y=head->y;
            nexthead->next=head;
            head=nexthead;
            q=head;
            if(nexthead->x==food->x && nexthead->y==food->y)//有食物
            {
                while(q!=NULL)
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");
                    q=q->next;
                }
                score=score+add;
    			speedup();
                createfood();
            }
            else                                //没有食物
            {
                while(q->next->next!=NULL)
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");
                    q=q->next;        
                }
                gotoxy(q->next->x,q->next->y);
    			color(3);
                printf("■");
                free(q->next);
                q->next=NULL;
            }
        }
        if(status==R)
        {
            nexthead->x=head->x+2;        //向右前进时,x坐标向右移动+2,y坐标不动
            nexthead->y=head->y;
            nexthead->next=head;
            head=nexthead;
            q=head;
            if(nexthead->x==food->x && nexthead->y==food->y)//有食物
            {
                while(q!=NULL)
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");
                    q=q->next;
                }
                score=score+add;
    			speedup();
                createfood();
            }
            else                                         //没有食物
            {
                while(q->next->next!=NULL)
                {
                    gotoxy(q->x,q->y);
                    color(14);
                    printf("◆");
                    q=q->next;        
                }
                gotoxy(q->next->x,q->next->y);
    			color(3);
                printf("■");
                free(q->next);
                q->next=NULL;
            }
        }
        if(biteself()==1)       //判断是否会咬到自己
        {
            endgamestatus=2;
            endgame();
        }
    }
    
    /*
    	控制键盘按键
    */
    void keyboardControl()
    {
    	status=R;       //初始蛇向右移动
        while(1)
        {
    		scoreandtips();
            if(GetAsyncKeyState(VK_UP) && status!=D)            //GetAsyncKeyState函数用来判断函数调用时指定虚拟键的状态
            {
                status=U;           //如果蛇不是向下前进的时候,按上键,执行向上前进操作
            }
            else if(GetAsyncKeyState(VK_DOWN) && status!=U)     //如果蛇不是向上前进的时候,按下键,执行向下前进操作
            {
                status=D;
            }
            else if(GetAsyncKeyState(VK_LEFT)&& status!=R)      //如果蛇不是向右前进的时候,按左键,执行向左前进
            {
                status=L;
            }
            else if(GetAsyncKeyState(VK_RIGHT)&& status!=L)     //如果蛇不是向左前进的时候,按右键,执行向右前进
            {
                status=R;
            }
            if(GetAsyncKeyState(VK_SPACE))		//按暂停键,执行pause暂停函数
            {
                while(1)
    			{
    				Sleep(300); //sleep()函数,头文件#include <unistd.h>  令进程暂停,直到达到里面设定的参数的时间
    				if(GetAsyncKeyState(VK_SPACE))      //按空格键暂停
    				{
    					break;
    				}
    				
    			}       
            }
            else if(GetAsyncKeyState(VK_ESCAPE))
            {
                endgamestatus=3;    //按esc键,直接到结束界面
                break;
            }
            else if(GetAsyncKeyState(VK_F1))    //按F1键,加速
            {
                speedup();
            }
            else if(GetAsyncKeyState(VK_F2))    //按F2键,减速
            {
            	speeddown();
                
            }
            Sleep(sleeptime);
            snakemove();
        }
    }
    
    /*
    	储存最高分进文件
    */
    void File_in()
    {
    	FILE *fp;
    	fp = fopen("save.txt", "w+");       //以读写的方式建立一个名为save.txt的文件
    	fprintf(fp, "%d", score);           //把分数写进文件中
    	fclose(fp);                         //关闭文件
    }
    
    /*
    	在文件中读取最高分
    */
    void File_out()
    {
    	FILE *fp;
    	fp = fopen("save.txt", "a+");       //打开文件save.txt
    	fscanf(fp, "%d", &HighScore);       //把文件中的最高分读出来
    	fclose(fp);                         //关闭文件
    }
    
    /*
    	游戏说明
    */
    void explation()
    {
    	int i,j = 1;
        system("cls");
        color(15);
        gotoxy(44,3);
        printf("游戏说明");
        color(2);
        for (i = 6; i <= 22; i++)   //输出上下边框===
    	{
    		for (j = 20; j <= 76; j++)  //输出左右边框||
    		{
    			gotoxy(j, i);
    			if (i == 6 || i == 22) printf("=");
    			else if (j == 20 || j == 75) printf("||");
    		}
    	}
        color(3);
        gotoxy(30,8);
        printf("tip1: 不能撞墙,不能咬到自己");
        color(10);
        gotoxy(30,11);
        printf("tip2: 用↑.↓.←.→分别控制蛇的移动");
        color(14);
        gotoxy(30,14);
        printf("tip3: F1 为加速,F2 为减速");
        color(11);
        gotoxy(30,17);
        printf("tip4: 按空格键暂停游戏,再按空格键继续");
        color(4);
        gotoxy(30,20);
        printf("tip5: Esc :退出游戏");
        getch();                //按任意键返回主界面
        system("cls");
        printsnake();
        welcometogame();
    }
    
    /*
    	结束游戏
    */
    void endgame()
    {
        system("cls");
        if(endgamestatus==1)
        {
            
    		Lostdraw();
    		gotoxy(35,9);
        	color(7);
    		printf("对不起,您撞到墙了。游戏结束!");
        }
        else if(endgamestatus==2)
        {
            
            Lostdraw();
            gotoxy(35,9);
        	color(7);
            printf("对不起,您咬到自己了。游戏结束!");
        }
        else if(endgamestatus==3)
        {
    		Lostdraw();
    		gotoxy(40,9);
        	color(7);
            printf("您已经结束了游戏。");
        }
        gotoxy(43,12);
        color(14);
        printf("您的得分是 %d",score);
    
    	if(score >= HighScore)
    	{
    		color(10);
    		gotoxy(33,16);
    		printf("创纪录啦!最高分被你刷新啦,真棒!!!");
    		File_in();              //把最高分写进文件
    	}
    	else
    	{
    		color(10);
    		gotoxy(33,16);
    		printf("继续努力吧~ 你离最高分还差:%d",HighScore-score);
    	}
    	choose();
    }
    
    /*
    	边框下面的分支选项
    */
    void choose()
    {
    	int n;
    	gotoxy(30,23);
    	color(12);
    	printf("重玩一局 [1]");
    	gotoxy(55,23);
    	printf("溜了溜了 [2]");
    	gotoxy(45,25);
    	color(11);
    	printf("选择:");
    	scanf("%d", &n);
        switch (n)
        {
    	case 1:
    		system("cls");          //清屏
    		score=0;                //分数归零
    		sleeptime=200;			//设定初始速度
    		add = 10;				//使add设定为初值,吃一个食物得分10,然后累加
    		printsnake();           //返回欢迎界面
    		welcometogame();
    		break;
    	case 2:
    		exit(0);                //退出游戏
    		break;
    	default:
    		gotoxy(35,27);
    		color(12);
    		printf("※※您的输入有误,请重新输入※※");
    		system("pause >nul");
    		endgame();
    		choose();
    		break;
    	}
    
    }
    
    /*
    	失败界面
    */
    void Lostdraw()
    {
    	system("cls");
    	int i;
    	gotoxy(45,1);
    	color(6);
    	printf(" |-----|   ");		//匹诺曹的帽子
    	gotoxy(45,2);
    	color(6);
    	printf(" |     |   ");
    	gotoxy(43,3);
    	color(6);
    	printf("-------------");
    
    	gotoxy(44,4);
    	color(14);
    	printf("(");
    
    	gotoxy(47,4);
    	color(15);
    	printf(" > <");				//眼睛
    
    	gotoxy(54,4);
    	color(14);
    	printf(")");
    
    	gotoxy(17,5);
    	color(11);
    	printf("+------------------------");	//上边框
    
    	gotoxy(35,5);
    	color(14);
    	printf("oOOo");
    
    	gotoxy(39,5);
    	color(11);
    	printf("----------");					//上边框
    
    	gotoxy(48,5);
    	color(14);
    	printf("| |");				//鼻子
    	gotoxy(48,6);
    	color(14);
    	printf("|_|");
    
    	gotoxy(51,5);
    	color(11);
    	printf("----------");					//上边框
    
    	gotoxy(61,5);
    	color(14);
    	printf("oOOo");
    
    	gotoxy(65,5);
    	color(11);
    	printf("-----------------+");			//上边框
    	
    	for(i = 6;i<=19;i++)					//竖边框
    	{
    		gotoxy(17,i);
    		printf("|");
    		gotoxy(82,i);
    		printf("|");
    	}
    
    	gotoxy(17,20);
    	printf("+------------------------------------------");	//下边框
    
    	gotoxy(60,20);
    	color(11);
    	printf("----------------------+");						//下边框
    
    }
    
    /*
    	主函数
    */
    int main(int argc, char* argv[])
    {
    	system("mode con cols=110 lines=30");	//设置控制台宽高
    	printsnake();							//绘制字符蛇
    	welcometogame();						//欢迎界面
    	//File_out();								//读取文件信息
    	//keyboardControl();						//控制键盘按钮
    	endgame();								//游戏结束
    	return 0;
    }
    
    

    3、简单到炸的自制迷宫

    本程序中的迷宫及其简单,你可以尝试修改地图,增加难度。

    #include<stdio.h>
    #include<stdlib.h>
    #include<windows.h>
    #include<conio.h>
    int main()
    {
    	
    	char a[1000][1000] = {"##########",
    						"#o #  #   ",
    						"# ## ## ##",
    						"#  #    ##",
    						"##   ## ##",
    						"##########" };
    	int i, x = 1, y = 1;
    	int count=0;
    	printf("\n\n\t请不要使用中文输入法!\n\t操作方式:上下左右=WSAD\n\t o 代表你操作的人物, # 代表墙体。\n\t开始你的游戏吧!\n\n\n");
    	for (i = 0; i < 11; i++)
    		puts(a[i]);
    	char ch;
    	while (x != 1|| y != 9)
    	{
    		
    		ch = _getch();
    		count++;
    		if (ch == 's')
    		{
    			if (a[x + 1][y] != '#')
    			{
    				a[x][y] = ' ';
    				x++;
    				a[x][y] = 'o';
    			}
    		}
    		if (ch == 'w')
    		{
    			if (a[x - 1][y] != '#')
    			{
    				a[x][y] = ' ';
    				x--;
    				a[x][y] = 'o';
    			}
    		}
    		if (ch == 'a')
    		{
    			if (a[x][y - 1] != '#')
    			{
    				a[x][y] = ' ';
    				y--;
    				a[x][y] = 'o';
    			}
    		}
    		if (ch == 'd')
    		{
    			if (a[x][y + 1] != '#')
    			{
    				a[x][y] = ' ';
    				y++;
    				a[x][y] = 'o';
    			}
    		}
     
    		system("cls");
    		if (x == 1 && y == 9)
    			printf("成功过关\n");
    		for (i = 0; i < 6; i++)
    			puts(a[i]);
    	}
    	printf("你一共走了%d步\n", count);
    	Sleep(5000);
    	return 0;
    }
    
    

    4、不忍直视的双人飞机对战

    芜湖,我愿称之为无与伦比。

    /*--------------------------------------
    project: 双人小游戏
    anthor:   LLz 
    操作    移动    逆、顺时针旋转   发射子弹 
    玩家1   4568    7 9 			      0 
    玩家2   adws 	  q e 			      空格        
    --------------------------------*/ 
    #include <stdio.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <windows.h>
    // 游戏画面尺寸
    #define High 20  
    #define Width 100        
    // 全局变量
    int position_x,position_y,p_x,p_y,turn_a,turn_b,num_a,num_b,num_max,life_a = 10,life_b = 10; // 飞机位置
    int canvas[High][Width] = {0}; // 二维数组存储游戏画布中对应的元素
                            // 0为空格,1为飞机*,2为子弹|,3为敌机@
    int next[8][2] = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}}; //从右  右下  下  左下 
    int bullet_a[21][4];
    int bullet_b[21][4];   //a b玩家子弹20发;            
    void gotoxy(int x,int y)  //光标移动到(x,y)位置
    {
        HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
        COORD pos;
        pos.X = x;
        pos.Y = y;
        SetConsoleCursorPosition(handle,pos);
    } 
    void startup() // 数据初始化
    {
    	num_a = 0;
    	num_b = 0;
    	turn_a = 0;
    	turn_b = 0;
    	p_x = High/2;//左边飞机
    	p_y = Width* 4 / 5;
    	canvas[p_x][p_y] = 5;//?
    	position_x = High/2;//右边飞机
    	position_y = Width/5;
    	canvas[position_x][position_y] = 1;	
    }
    void show()  // 显示画面
    {
    	gotoxy(0,0);  // 光标移动到原点位置,以下重画清屏
    	int i,j;
    	for (i=0;i<High;i++)
    	{
    		for (j=0;j<Width;j++)
    		{
    			if( i == 0 || i == High -1 || j == 0 || j == Width -1){
    				canvas[i][j] = 4;
    				printf("0");
    				continue;
    			}
    			if (canvas[i][j]==0)
    				printf(" ");   //   输出空格
    			else if (canvas[i][j]==1)
    				printf("A");   //   输出飞机a
    			else if (canvas[i][j]==2)
    				printf("B");   //   输出飞机B
    			else if (canvas[i][j]==3)
    				printf("o");   //  输出子弹o 
    			else if (canvas[i][j]==4)
    				printf("+");   //	输出飞机a指向 
    			else if (canvas[i][j]==5)
    				printf("+");   //	输出飞机b指向  
    		}
    		printf("\n");
    	}
    	//初始血量显示
    	printf("A:");
    	for( i = 1; i <= 10; i++ )
    		if( i <= life_a)
    			printf("■");
    		else printf(" ");
    	printf("\nB: ");
    	for( i = 1; i <= 10; i++ )
    		if( i <= life_b)
    			printf("■");
    		else printf(" ");
    }	
    void updateWithoutInput()  // 与用户输入无关的更新
    {	
    	int i,j,k;
    	num_max = num_a > num_b? num_a : num_b;
    	for( i = 1; i <= num_max; i++){
    			if( bullet_a[i][2] == 0 || bullet_a[i][2] == High - 1){
    				bullet_a[i][0] = -bullet_a[i][0];
    			}
    			else if( bullet_a[i][3] == 0 || bullet_a[i][3] == Width - 1){
    				bullet_a[i][1] = -bullet_a[i][1];
    			}
    			if( bullet_b[i][2] == 0 || bullet_b[i][2] == High - 1){
    				bullet_b[i][0] = -bullet_b[i][0];
    			}
    			else if( bullet_b[i][3] == 0 || bullet_b[i][3] == Width - 1){
    				bullet_b[i][1] = -bullet_b[i][1];
    			}
    			canvas[ bullet_a[i][2] ][ bullet_a[i][3] ] = 0;
    			canvas[ bullet_b[i][2] ][ bullet_b[i][3] ] = 0;
    			bullet_a[i][2] += bullet_a[i][0];
    			bullet_a[i][3] += bullet_a[i][1];
    			bullet_b[i][2] += bullet_b[i][0];
    			bullet_b[i][3] += bullet_b[i][1];
    			canvas[ bullet_a[i][2] ][ bullet_a[i][3] ] = 3;
    			canvas[ bullet_b[i][2] ][ bullet_b[i][3] ] = 3;
    	}
    	for (k=1;k<=num_max;k++)
    	{
    		if (((position_x==bullet_a[k][2]) && (position_y==bullet_a[k][3]))||((position_x==bullet_b[k][2]) && (position_y==bullet_b[k][3])))  // 敌机撞到我机
    		{
    			life_a--;
    			if( life_a <= 0){
    				printf("A 玩家失败!\n");
    				Sleep(3000);
    				system("pause");
    				exit(0);
    			}
    		}
    		if (((p_x==bullet_a[k][2]) && (p_y==bullet_a[k][3]))||((p_x==bullet_b[k][2]) && (p_y==bullet_b[k][3])))  // 敌机撞到我机
    		{
    			life_b--;
    			if( life_b <= 0){
    				printf("B 玩家失败!\n");
    				Sleep(3000);
    				system("pause");
    				exit(0);
    			}
    		}
    	}
    }
    void updateWithInput()  // 与用户输入有关的更新
    {
    	char input;
    	if(kbhit())  // 判断是否有输入
    	{
    		input = getch();  // 根据用户的不同输入来移动,不必输入回车
    		if (input == 'a' && position_y>1) 
    		{
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 0;
    			canvas[position_x][position_y] = 0;
    			position_y--;  // 位置左移
    			canvas[position_x][position_y] = 1;
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 4;
    		}
    		else if (input == 'd' && position_y<Width-2)
    		{
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 0;
    			canvas[position_x][position_y] = 0;
    			position_y++;  // 位置右移
    			canvas[position_x][position_y] = 1;
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 4;
    		}
    		else if (input == 'w' && position_x > 1)
    		{
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 0;
    			canvas[position_x][position_y] = 0;
    			position_x--;  // 位置上移
    			canvas[position_x][position_y] = 1;
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 4;
    		}
    		else if (input == 's'&& position_x < High - 2)
    		{
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 0;
    			canvas[position_x][position_y] = 0;
    			position_x++;  // 位置下移
    			canvas[position_x][position_y] = 1;
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 4;
    		}		
    		else if (input == ' ' && num_a <= 20)  // 发射子弹
    		{
    			num_a++;
    			bullet_a[num_a][0] = next[turn_a][0];
    			bullet_a[num_a][1] = next[turn_a][1];
    			bullet_a[num_a][2] = position_x + bullet_a[num_a][0];
    			bullet_a[num_a][3] = position_y + bullet_a[num_a][1];
    			canvas[ bullet_a[num_a][2] ][ bullet_a[num_a][3] ] = 3;
    		}
    		else if (input == 'q')  // 炮弹换方向 
    		{
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 0;
    			turn_a--;
    			if(turn_a < 0)
    				turn_a = 7;
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 4;
    		}
    		else if (input == 'e')  //  炮弹换方向 
    		{
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 0;
    			turn_a++;
    			if(turn_a > 7)
    				turn_a = 0;
    			canvas[position_x + next[turn_a][0]][position_y + next[turn_a][1]] = 4;
    		}
    		else if (input == '4' && position_y>1) 
    		{
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 0;
    			canvas[p_x][p_y] = 0;
    			p_y--;  // 位置左移
    			canvas[p_x][p_y] = 2;
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 5;
    		}
    		else if (input == '6' && p_y<Width-2)
    		{
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 0;
    			canvas[p_x][p_y] = 0;
    			p_y++;  // 位置右移
    			canvas[p_x][p_y] = 2;
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 5;
    		}
    		else if (input == '8' && p_x > 1)
    		{
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 0;
    			canvas[p_x][p_y] = 0;
    			p_x--;  // 位置上移
    			canvas[p_x][p_y] = 2;
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 5;
    		}
    		else if (input == '5' && p_x < High - 2)
    		{
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 0;
    			canvas[p_x][p_y] = 0;
    			p_x++;  // 位置下移
    			canvas[p_x][p_y] = 2;
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 5;
    		}		
    		else if (input == '0' && num_b <= 20)  // 发射子弹
    		{
    			num_b++;
    			bullet_b[num_b][0] = next[turn_b][0];
    			bullet_b[num_b][1] = next[turn_b][1];
    			bullet_b[num_b][2] = p_x + bullet_b[num_b][0];
    			bullet_b[num_b][3] = p_y + bullet_b[num_b][1];
    			canvas[ bullet_b[num_b][2] ][ bullet_b[num_b][3] ] = 3;
    		}	
    		else if (input == '7')  // 炮弹换方向 
    		{
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 0;
    			turn_b--;
    			if(turn_b < 0)
    				turn_b = 7;
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 5;
    		}
    		else if (input == '9')  //  炮弹换方向 
    		{
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 0;
    			turn_b++;
    			if(turn_b > 7)
    				turn_b = 0;
    			canvas[p_x + next[turn_b][0]][p_y + next[turn_b][1]] = 5;
    		}
    	}
    }
    int main()
    {
    	startup();  // 数据初始化
    	system("color 30");
    	while (1)  // 游戏循环执行
    	{
    		show();  // 显示画面
    		updateWithoutInput();  // 与用户输入无关的更新
    		updateWithInput();  // 与用户输入有关的更新
    	}
    	return 0;
    }
    
    
    展开全文
  • C语言制作游戏——贪吃蛇

    万次阅读 多人点赞 2017-09-07 21:06:30
    利用c语言写的一个贪吃蛇小游戏,界面精良,经测试没什么bug。欢迎大家提出建议

    【 声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:rfhklwt@163.com】

    成品图

    这里写图片描述

    游戏模块组成

    • 开拓疆土——绘制游戏窗口
    • 上帝造蛇和食物——初始化蛇和食物
    • 自动裁判员——菜单信息
    • 食物从天而降——食物的随机生成
    • 让蛇扭起来——移动蛇
    • 大开吃戒——吃食物
    • 瞬间移动——穿墙
    • 生命凋零——蛇死亡
    • 一切的开始——游戏开始
    • 一切的结束——结束游戏
    • **上帝控制台——主函数 **

    开拓疆土——绘制游戏窗口

    大家都玩过游戏,游戏一定有一个限制框来限制我们游戏主人公的行动,说白了就是地图,这就是我们的游戏窗口。见如下代码

    void MakeFrame(HANDLE hOut)
    {
    	//打印边框
    	SetPosition(hOut, FRAMEX, FRAMEY);										//设置光标为左上角坐标处
    	printf("┏");
    
    	SetPosition(hOut, FRAMEX + 2 * FRAMEWIDTH - 2, FRAMEY);					//设置光标为右上角坐标处
    	printf("┓");
    	
    	SetPosition(hOut, FRAMEX, FRAMEY + FRAMEHEIGHT);						//设置光标为左下角坐标处
    	printf("┗");
    
    	SetPosition(hOut, FRAMEX + 2 * FRAMEWIDTH - 2, FRAMEY + FRAMEHEIGHT);	//设置光标为右下角坐标处
    	printf("┛");
    
    	//水平-顶端
    	for (int i = 2; i < 2 * FRAMEWIDTH - 2; i+=2)
    	{
    		SetPosition(hOut, FRAMEX + i, FRAMEY);
    		printf("━");
    	}
    
    	//水平-底端
    	for (int i = 2; i < 2 * FRAMEWIDTH - 2; i += 2)
    	{
    		SetPosition(hOut, FRAMEX + i, FRAMEY + FRAMEHEIGHT);
    		printf("━");
    	}
    
    	//竖直-左端
    	for (int i = 1; i < FRAMEHEIGHT; i++)
    	{
    		SetPosition(hOut, FRAMEX, FRAMEY + i);
    		printf("|");
    	}
    
    	//竖直-右端
    	for (int i = 1; i < FRAMEHEIGHT; i++)
    	{
    		SetPosition(hOut, FRAMEX + 2 * FRAMEWIDTH - 2, FRAMEY + i);
    		printf("|");
    	}
    
    	//打印游戏名称
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH - 5, FRAMEY - 2);
    	printf("贪吃蛇游戏");
    
    	//打印游戏操作
    	SetPosition(hOut, FRAMEX, FRAMEY + FRAMEHEIGHT + 2);
    	printf("游戏操作:	上: ↑	左: ←	右: →	下: ↓");
    	SetPosition(hOut, FRAMEX, FRAMEY + FRAMEHEIGHT + 4);
    	printf("加速: 长按方向键	退出: ESC	暂停:Space");
    	
    }
    

    以上代码需要说明的有
    1. SetPosition(HANDLE hOut, int x, int y)函数:

    void SetPosition(HANDLE hOut, int x, int y)
    {
    	COORD pos;
    	pos.X = x;
    	pos.Y = y;
    	SetConsoleCursorPosition(hOut, pos);
    }
    

    从上式代码可以看出,SetPosition(HANDLE hOut, int x, int y)函数是用于把光标放在我们需要的(x, y)上,从而能在(x, y)处打印我们需要的东西。

    **2. 常量:FRAMEX和FRAMEY和FRAMEHEIGHT和FRAMEWIDTH的含义 **
    正如常量的名字一样,我们在主函数的前面定义了这四个常量,其含义和数值如下:

    #define FRAMEX	4				//窗口左上角横坐标
    #define FRAMEY	4				//窗口左上角纵坐标
    #define FRAMEWIDTH	25			//游戏窗口宽度
    #define FRAMEHEIGHT	25			//游戏窗口高度
    

    上帝造蛇和食物——初始化蛇和食物

    根据蛇在本游戏中具有的性质,我们将这些性质打包到名为蛇的结构体中,同理也定义了一个食物的结构体。代码如下:
    
    //蛇
    typedef struct SNAKE
    {
    	int x[100];					//蛇的横坐标, x[0]蛇尾横坐标
    	int y[100];					//蛇的纵坐标, y[0]蛇尾纵坐标
    	int nCount;					//蛇吃食物总数
    	int nLength;				//蛇的长度
    	int nSpeed;					//蛇的移动速度
    }Snake;
    
    //食物
    typedef struct FOOD
    {
    	int x;	//食物的横坐标
    	int y;	//食物的纵坐标
    }Food;
    
    //初始化蛇
    void InitSnake(Snake* pSnake)
    {
    	pSnake->x[0] = FRAMEX + 2;					//初始化蛇尾的横坐标
    	pSnake->y[0] = FRAMEX + FRAMEHEIGHT / 2;	//初始化蛇尾的纵坐标
    	pSnake->nSpeed = 80;						//初始化蛇的移动速度
    	pSnake->nCount = 0;							//食物个数
    	pSnake->nLength = 3;						//蛇身长度
    
    	for (int i = 1; i < pSnake->nLength; i++)
    	{
    		pSnake->x[i] = pSnake->x[i - 1] + 2;
    		pSnake->y[i] = pSnake->y[i - 1];
    	}
    }		
    
    //打印蛇
    void PrintfSnake(HANDLE hOut, Snake* pSnake)
    {
    	for (int i = 0; i < pSnake->nLength; i++)
    	{
    		SetPosition(hOut, pSnake->x[i], pSnake->y[i]);
    
    		//打印蛇尾
    		if (i == 0)
    		{
    			SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_BLUE);
    			printf("○");
    			SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    		}
    			
    		//打印蛇头
    		else if (i == pSnake->nLength - 1)
    		{
    			SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_GREEN);
    			printf("¤");
    			SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    		}
    			
    		//打印蛇身
    		else
    		{
    			SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED);
    			printf("⊙");
    			SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    		}
    			
    	}
    }
    

    自动裁判员——菜单信息

    作为一个心系玩家的开发者。我们需要将玩家在玩游戏时所产生的一些信息包括等级、得分等打印到屏幕上。这样可以让玩家在游戏得分中得到鼓舞,不断挑战自己。

    void PrintfMenu(HANDLE hOut, Snake* pSnake, Food* pFood)	
    {
    	//游戏等级
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 1);
    	printf("游戏等级:%d", pSnake->nCount / 5 + 1);			//每吃五个食物升一级
    
    	//游戏得分
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 3);
    	printf("游戏得分:%d分", pSnake->nCount);				   //每吃一个食物得一分
    
    	//食物个数
    	
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 5);
    	printf("所吃食物总个数:%d个", pSnake->nCount);			 //玩家所吃的食物总数
    
    	//游戏速度
    	if (pSnake->nSpeed == 80)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:1");	
    	}
    	else if (pSnake->nSpeed == 70)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:2");
    	}
    	else if (pSnake->nSpeed == 60)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:3");
    	}
    	else if (pSnake->nSpeed == 50)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:4");
    	}
    	else if (pSnake->nSpeed == 40)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:5");
    	}
    	else if (pSnake->nSpeed == 30)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:6");
    	}
    	else
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 7);
    		printf("贪吃蛇的速度级别为:逆天级别");
    	}
    
    
    	//食物坐标
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 9);
    	printf("食物的坐标:(%d, %d)", pFood->x, pFood->y);
    	
    	//温馨提示:
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 12);
    	SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_BLUE);
    	printf("游戏规则:吃到食物,碰到自身则蛇死亡。");
    
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 14);
    	printf("PS:这不是普通的墙哦,可以穿过去的(*^▽^*)");
    	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    
    }
    

    食物从天而降——食物的随机生成

    关于食物的生成,有一下几点需要注意的:

    1. 食物出现的位置不能超过我们界定的游戏窗口
    2. 食物不能产生在我们的蛇身上(不然我们就看不到食物了)

    根据以上两点,可写出如下代码:

    void MakeFood(HANDLE hOut, Snake* pSnake, Food* pFood)
    {
    	srand((unsigned)time(NULL));
    	/*
    	1.在游戏框架内
    	2.不在蛇身上
    	*/
    	while(1) 
    	{
    		pFood->x = rand() % (FRAMEWIDTH - 1);		//0 - FRAMEWIDTH-1;
    		pFood->y = rand() % FRAMEHEIGHT;			//0 - FRAMEHEIGHT-1;
    
    		if (pFood->x == 0 || pFood->y == 0)			//食物不能再边界处
    			continue;
    
    		pFood->x = 2 * pFood->x + FRAMEX;
    		pFood->y += FRAMEY;
    
    		//判断食物是不是在蛇的身上
    		int temp; 
    		for (temp = 0; temp < pSnake->nLength; temp++)
    		{
    			if (pFood->x == pSnake->x[temp] && pFood->y == pSnake->y[temp])
    				break;
    		}
    
    		if (temp == pSnake->nLength)
    		{
    			SetPosition(hOut, pFood->x, pFood->y);
    			SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_RED);
    			printf("◎");
    			SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    
    			break;
    		}
    	}
    }	
    

    让蛇扭起来——移动蛇

    看到这里,大家想想要如何让蛇移动起来呢?我们从前面的代码知道了整条蛇由众多的小蛇块组成,其中x[0]和y[0]是蛇尾的坐标。那么我们只要将让蛇尾去代替蛇尾前一块蛇的位置,以此不断推前,就能完成蛇的移动。在移动蛇的位置我们不考虑蛇头的位置,蛇头的运动由我们的玩家来控制,在StartGame()函数里面执行,现在可先不管。

    这里写图片描述

    如图,假设这条蛇的长度为6,x[5]为蛇头,x[0]为蛇尾。那么下一个时刻,除去蛇头,其余部位的位置应该如上图。x[0]所在的位置应该没有蛇的部位,反而,x[0]的位置挪到了x[1]的位置,以此类推,完成蛇的移动。至于蛇头的位置去哪了呢。不急~且看后文。看懂这个移动的原理后我们就可以写出下面的代码:

    void MoveSnake(HANDLE hOut, Snake* pSnake)
    {
    	SetPosition(hOut, pSnake->x[0], pSnake->y[0]);
    	printf("  ");
    
    	//后一个坐标代替前一个坐标
    	for (int i = 1; i < pSnake->nLength; i++)
    	{
    		pSnake->x[i - 1] = pSnake->x[i];
    		pSnake->y[i - 1] = pSnake->y[i];
    	}
    
    }
    

    大开吃戒——吃食物

    这部分没什么好讲的,大家看看代码就能理解了~

    void EatFood(HANDLE hOut, Snake* pSnake, Food* pFood)
    {
    	if (pSnake->x[pSnake->nLength - 1] == pFood->x && pSnake->y[pSnake->nLength - 1] == pFood->y)
    	{
    		//如果蛇头位置与食物位置相同,吃食物
    		pSnake->nLength++;
    		for (int i = pSnake->nLength - 1; i > 0; i--)
    		{
    			pSnake->x[i] = pSnake->x[i - 1];
    			pSnake->y[i] = pSnake->y[i - 1];
    		}
    		pSnake->x[0] = tail[0];		//得到蛇尾移动前的横坐标
    		pSnake->y[0] = tail[1];		//得到蛇尾移动前的纵坐标  
    
    		//重新产生食物
    		MakeFood(hOut, pSnake, pFood);
    		pSnake->nCount++;			//食物的数量加一
    
    		//当蛇吃Up_level个食物时,速度加快Up_speed毫秒并且升一级
    		if (pSnake->nCount % 6 == 0)
    			pSnake->nSpeed -= 10;
    	}
    }
    

    以上代码需要说明的有一点。
    tail数组的含义
    在主函数的前面,我们定义了一个全局变量tail[2]数组,来记录蛇尾移动前的位置

    int tail[2];     //用于记住蛇尾坐标,其中tail[0]、tail[1]分别表示横、竖坐标
    

    ##瞬间移动——穿墙
    大家看成品图应该看到了,那一句蓝色的提示语,是的,在本游戏中,这条蛇是可以穿墙的,这穿墙不是指穿过墙跑到界外。而是,比如蛇撞到右边的墙壁中,则会从左边的墙壁出现。

    void ThroughWall(HANDLE hOut, Snake* pSnake, char ch)
    {
    	//如果蛇在上框且向上移动,穿墙
    	if (ch == 72 && pSnake->y[pSnake->nLength - 1] == FRAMEY)
    	{
    		pSnake->y[pSnake->nLength - 1] = FRAMEY + FRAMEHEIGHT - 1;
    	}
    
    	//如果蛇在下框且向下移动,穿墙
    	if (ch == 80 && pSnake->y[pSnake->nLength - 1] == FRAMEY + FRAMEHEIGHT)
    	{
    		pSnake->y[pSnake->nLength - 1] = FRAMEY + 1;
    	}
    
    	//如果蛇在右框且向右移动,穿墙
    	if (ch == 75 && pSnake->x[pSnake->nLength - 1] == FRAMEX)
    	{
    		pSnake->x[pSnake->nLength - 1] = FRAMEX + 2 * FRAMEWIDTH - 4;
    	}
    
    	//如果蛇在左框且向左移动,穿墙
    	if (ch == 77 && pSnake->x[pSnake->nLength - 1] == FRAMEX + 2 * FRAMEWIDTH - 2)
    	{
    		pSnake->x[pSnake->nLength - 1] = FRAMEX + 2;
    	}
    }
    

    ##生命凋零——蛇死亡
    在本游戏中,蛇死亡的条件很简单,碰到自身就死了。

    bool IfSnakeDie(Snake* pSnake)
    {
    	//当蛇头碰到自身时,蛇死,返回值为TRUE
    	for (int i = 0; i < pSnake->nLength - 1; i++)
    	{
    		if (pSnake->x[pSnake->nLength - 1] == pSnake->x[i] && pSnake->y[pSnake->nLength - 1] == pSnake->y[i])
    			return TRUE;
    	}
    	return FALSE;
    }
    

    ##一切的开始——游戏开始

    bool StartGame()
    {
    	unsigned char chOld = 77;
    	unsigned char chNow = 77;
    	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    	
    	//定义蛇
    	Snake snake;
    
    	//定义食物
    	Food food;
    		
    	//制作游戏窗口
    	MakeFrame(hOut);
    	
    	//初始化蛇
    	InitSnake(&snake);
    	
    	//产生食物
    	MakeFood(hOut, &snake, &food);
    
    	while (1)
    	{
    		//打印菜单信息
    		PrintfMenu(hOut, &snake, &food);
    
    		tail[0] = snake.x[0];       //记住蛇尾的横坐标
    		tail[1] = snake.y[0];       //记住蛇尾的纵坐标
    
    		bool speedUp = FALSE;
    		//判断键盘是否按下
    		if (kbhit())
    		{
    			chNow = getch();
    			//Sleep(10);			
    			if (kbhit())
    				speedUp = TRUE;
    		}
    
    		switch (chNow)
    		{
    			case 72:	//向上
    			{
    							
    							MoveSnake(hOut, &snake);
    							if (chOld == 80)		//如果蛇调头,则无视调头继续走
    							{
    								snake.y[snake.nLength - 1] += 1;
    								chNow = chOld;
    								break;
    							}
    							chOld = chNow;
    							snake.y[snake.nLength - 1] -= 1;
    							break;
    			}
    			case 80:	//向下
    			{
    							MoveSnake(hOut, &snake);
    							if (chOld == 72)
    							{
    								snake.y[snake.nLength - 1] -= 1;
    								chNow = chOld;
    								break;
    							}
    							chOld = chNow;
    							snake.y[snake.nLength - 1] += 1;
    							break;
    			}
    			case 75:	//向左
    			{
    							MoveSnake(hOut, &snake);
    							if (chOld == 77)
    							{
    								snake.x[snake.nLength - 1] += 2;
    								chNow = chOld;
    								break;
    							}
    							chOld = chNow;
    							snake.x[snake.nLength - 1] -= 2;
    							break;
    			}
    			case 77:	//向右
    			{
    							MoveSnake(hOut, &snake);
    							if (chOld == 75)
    							{
    								snake.x[snake.nLength - 1] -= 2;
    								chNow = chOld;
    								break;
    							}
    							chOld = chNow;
    							snake.x[snake.nLength - 1] += 2;
    							break;
    			}
    			case 27:		//ESC键				
    							break;
    			case 32:		//暂停
    			{
    							
    							break;
    			}
    				
    			default:		//去掉其他按键的影响
    							chNow = chOld;
    							break;
    		}
    		//判断是否要出暂停提示
    		if (chNow != 32)	//清空暂停的提示
    		{
    			SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    			SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 16);
    			printf("                          ");
    			SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    		}
    		else//显示暂停指示
    		{
    			SetConsoleTextAttribute(hOut, FOREGROUND_INTENSITY | FOREGROUND_RED);
    			SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 16);
    			printf("已暂停,按方向键可继续游戏");
    			SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    		}
    		//穿墙
    		ThroughWall(hOut, &snake, chNow);
    		
    		//判断有无吃食物
    		EatFood(hOut, &snake, &food);
    		
    		//打印蛇
    		PrintfSnake(hOut, &snake);
    		
    		/*
    		游戏结束条件:
    		1. 蛇碰到自身
    		2. 按ESC键
    		*/
    		if (IfSnakeDie(&snake) == TRUE || chNow == 27)
    		{
    			SetPosition(hOut, FRAMEX + FRAMEWIDTH - 2, FRAMEY + FRAMEHEIGHT / 2 - 1);
    			bool State = OverGame(hOut, &snake);
    			return State;
    		}
    		PrintfMenu(hOut, &snake, &food);
    		if (speedUp == FALSE)
    		{
    			//SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 9);
    			//printf("          ");
    			Sleep(snake.nSpeed);
    		}			
    		else
    		{
    			//SetPosition(hOut, FRAMEX + FRAMEWIDTH * 2 + 5, FRAMEY + 9);
    			//printf("正在加速...");
    			Sleep(10);
    		}
    	}		
    }
    

    ##一切的结束——结束游戏

    bool OverGame(HANDLE hOut, Snake* pSnake)
    {
    	system("cls");
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH + 10, FRAMEY + FRAMEHEIGHT / 4);
    	printf("Game Over");
    	//打印得分
    	if (pSnake->nCount < 20)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH, FRAMEY + FRAMEHEIGHT / 4 + 2);
    		printf("好可惜哦!你的游戏得分为:%d分, 要不再来一盘突破自己?", pSnake->nCount);
    	}
    	else if (pSnake->nCount < 30)
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH, FRAMEY + FRAMEHEIGHT / 4 + 2);
    		printf("不错哦!你的游戏得分为:%d分, 我猜你还没拿出实力吧", pSnake->nCount);
    	}
    	else
    	{
    		SetPosition(hOut, FRAMEX + FRAMEWIDTH, FRAMEY + FRAMEHEIGHT / 4 + 2);
    		printf("哇好腻害(⊙o⊙)!你的游戏得分为:%d分, 你的手速已经超越地球人了", pSnake->nCount);
    	}
    	SetPosition(hOut, FRAMEX + FRAMEWIDTH, FRAMEY + FRAMEHEIGHT/4 + 4);
    	printf("重新开始游戏:Enter 	退出游戏:ESC");
    	
    	int userKey = 0;
    	while (1)
    	{
    		if ((userKey = getch()) == 13)
    			return FALSE;
    		else if ((userKey = getch()) == 27)
    			return TRUE;
    		else
    			continue;
    	}
    }							
    

    ##上帝控制台——主函数

    int main()
    {
    	while(1) 
    	{
    		//开始游戏
    		system("cls");
    	    bool State= StartGame();
    	    if (State)
    	    	break;
    	}
    	return 0;
    }
    
    展开全文
  • 使用C语言制作一个小游戏之扫雷游戏前言一、编辑这个小游戏的几个步骤二、各个步骤具体实现代码1.定义两个二维数组作为地图2.初始化地图3.打印showMap4.玩家输入要翻开地图的坐标5.判断输入坐标的合法性6.判断是否踩...
  • 关于C语言的猜数游戏,完全的自我编辑。的是初学的C。希望各位大佬给点分
  • 使用C语言完成的推箱子游戏,有关卡读写
  • 玩转c语言——c语言小游戏 迷宫小游戏(附源码)

    千次阅读 多人点赞 2021-10-02 08:35:24
    制作迷宫小游戏,我们要利用二维数组搭建场景,制作一个简易的迷宫 #include<stdio.h> #include<stdlib.h> #include<windows.h> #include<conio.h>//小游戏所需的所有头文件 int main...
  • 一个基于C语言小游戏,里面的内容写的都很详细,图片大多都是自己可以制作的,很适合初学编程的人参考、使用,提升自己的编程兴趣。
  • C语言制作扫雷游戏(结合图形库)

    千次阅读 2021-11-19 09:59:26
    游戏预览: 学习内容: 1.图形库文件的使用 2.C++的使用,如类函数 ...制作步骤: 1.生成游戏地图 如果想生成一个M x N的扫雷地图,是不是要定义一个map[M][N]的二维数组呢? 答案是否定的。 ...
  • 【实例简介】 【实例截图】见截图 【核心代码】 #... printf("恭喜你你了%d步完成了%d阶华容道!\n想再来一局按空格\n",c/2,n); char z=getchar(); if(z==' ') { system("cls"); goto T1; } Sleep(3000); return 0; }
  • C语言制作的20180615_益智小游戏-扫雷大作战带视频亲测有效.rar
  • C语言中的迷宫:你可以通过键盘上的“W”、“A”、“S”、“D”,4个按键来控制一个小球向上、下、左、右移动,目的就是让这个小球从起点走出迷宫。
  • C语言小游戏设计报告

    2021-05-19 14:20:42
    C语言小游戏设计报告课程设计名称:贪吃蛇小游戏专业班级:计科15-2学号:150809229姓名:XXX一.设计目标通过设计,培养学生对电脑的动手能力,使学生巩固《C语言程序设计》课程学习的内容,掌握编写程序的基本方法...
  • 用C语言实现简单小游戏

    万次阅读 多人点赞 2018-12-24 12:06:01
    1.用c语言实现三子棋。 #define _CRT_SECURE_NO_WARNINGS #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;time.h&amp;gt; #define ROW 3 #...
  • 用c语言编写小游戏:贪吃蛇

    万次阅读 多人点赞 2017-04-28 23:10:34
    用c语言编写小游戏:贪吃蛇

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,495
精华内容 4,598
关键字:

用c语言制作小游戏

c语言 订阅
友情链接: gdb-stub.rar