精华内容
下载资源
问答
  • 贪吃蛇C语言代码

    万次阅读 多人点赞 2016-04-18 15:37:59
    贪吃蛇C语言代码贪吃蛇C语言代码 手动贪吃蛇 智能贪吃蛇1.手动贪吃蛇/*蛇越长跑得越快*/ /*作者:SGAFPZ*/ #include #include #include #include //#include #include #include #

    贪吃蛇C语言代码

    1.手动贪吃蛇

    /*蛇越长跑得越快*/
    /*作者:SGAFPZ*/
    #include <stdio.h>
    #include <windows.h>
    #include <stdlib.h>
    #include <math.h>
    //#include <unistd.h>
    #include <conio.h>
    #include <string.h>
    #include <time.h>
    void food();
    void show();
    void move();
    void turn();
    void check();
    void ini();
    //void calculate();
    //int movable[4] = { 0, 1, 1, 0 };  //数组的下标表示方向,0123分别表示上下左右,下同
    //int distance[4] = { 9999, 9999, 9999, 9999 };
    int  dy[4] = { 0, 1, 0, -1 };
    int  dx[4] = { -1, 0, 1, 0 };
    int sum = 5;  //蛇总长度
    int over = 0;
    int speed;   
    //int foodx, foody;  //食物的坐标
    char map[17][17];
    
    struct snake {
        int x, y;  //身体坐标 
        int dir;  //方向(只有蛇头的方向是有用的) 
    } A[100];
    
    void ini() {  //初始化界面
        speed = 500;
        over = 0;
        sum = 5;
        //movable[0] = 0; movable[1] = 1; movable[2] = 1; movable[3] = 0;
        //distance[0] = 9999; distance[1] = 9999; distance[2] = 9999; distance[3] = 9999;
        int i, j;
        for (i = 0; i < 100; i++) {  //初始化蛇头和蛇身的数据
            A[i].dir = 0;
            A[i].x = 0;
            A[i].y = 0;
        }
        A[0].x = 1; A[0].y = 1;  //地图左上角设置一条长度为5的蛇
        A[1].x = 1; A[1].y = 2;
        A[2].x = 1; A[2].y = 3;
        A[3].x = 1; A[3].y = 4;
        A[4].x = 1; A[4].y = 5; A[4].dir = 1;
        srand(time(0));
        for (i = 0; i < 17; i++) {  //设置地图
            for (j = 0; j < 17; j++) {
                map[i][j] = '*';
            }
        }
        for (i = 1; i < 16; i++) {
            for (j = 1; j < 16; j++) {
                map[i][j] = ' ';
            }
        }
        //map[6][5] = '*'; map[6][6] = '*'; map[6][7] = '*';
        //map[7][5] = '*'; map[7][7] = '*';
        map[A[4].x][A[4].y] = 'H';  //设置蛇头
        for (i = 0; i < sum - 1; i++) {  //设置蛇身
            map[A[i].x][A[i].y] = 'X';
        }
        food();
        //calculate();
    }
    
    
    void show() {  //显示界面 
        int i, j, x, y;
        for (i = 0; i < 17; i++) {  //显示界面
            for (j = 0; j < 17; j++) {
                printf("%c", map[i][j]);
            }
            printf("\n");
        }
        while (1) {
            Sleep(speed);  //界面刷新速度
            turn();
            move();
            if (over) {  //设置蛇死掉后可以进行的操作 
                while (1) {
                    char ch = _getch();
                    if (ch == 113) {  //输入‘q’结束 
                        return;
                    }
                    else if (ch == 114) {  //输入‘r’重新开始 
                        ini();
                        break;
                    }
                }
            }
            system("cls");  //清屏 
            for (i = 0; i < 17; i++) {  //重新显示界面
                for (j = 0; j < 17; j++) {
                    printf("%c", map[i][j]);
                }
                printf("\n");
            }
            //calculate(); //计算并记录蛇头与食物距离
        }
    }
    
    void food() {  //生成食物
        int x, y;
        while (1) {
            x = (int)(15 * rand() / (RAND_MAX + 1.0));  //随机产生一组食物坐标
            y = (int)(15 * rand() / (RAND_MAX + 1.0));
            if (map[x][y] == ' ') {  //如果是空格则在该处生成食物
                map[x][y] = 'O';
                //foodx = x;  //记录食物坐标 
                //foody = y;
                break;
            }
        }
    }
    
    
    void move() {  //蛇移动
        int i, x, y;
        int t = sum;  //t记录当前蛇总长度 
        check();  //移动前检查按当前方向移动一步后的情况
        if (t == sum) {  //没有吃到苹果
            for (i = 0; i < sum - 1; i++) {
                if (i == 0) {  //蛇尾坐标处变成空格,把蛇尾坐标变成前一个蛇身的坐标 
                    map[A[i].x][A[i].y] = ' ';
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                else {  //每个蛇身坐标都变为它前一个蛇身的坐标
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                map[A[i].x][A[i].y] = 'X';  //把地图上蛇身坐标处的字符设置成‘X’
            }
            A[sum - 1].x = A[sum - 1].x + dx[A[sum - 1].dir];  //蛇头按当前方向移动一格 
            A[sum - 1].y = A[sum - 1].y + dy[A[sum - 1].dir];
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
        }
        else {  //吃到苹果(sum会加1)
            map[A[sum - 2].x][A[sum - 2].y] = 'X';  //把地图上原蛇头坐标处的字符设置成‘X’
            A[sum - 1].x = A[sum - 2].x + dx[A[sum - 2].dir];  //新蛇头的坐标是原蛇头沿当前方向移动一格后的坐标 
            A[sum - 1].y = A[sum - 2].y + dy[A[sum - 2].dir];
            A[sum - 1].dir = A[sum - 2].dir;  //新蛇头方向为原蛇头的方向
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
            food();
        }
        /*for(i = 0; i < 4; i++) {  //记录下能走的方向
            x = A[sum - 1].x + dx[i];
            y = A[sum - 1].y + dy[i];
            if(map[x][y] == ' ' || map[x][y] == 'O') {
                movable[i] = 1;  //能走就把对应方向的值设置为1 
            } else {
                if(x != A[0].x || y != A[0].y) {
                    movable[i] = 0;  //不能走就把对应方向的值设置为0 
                } else {
                    movable[i] = 1;
                }
            }
        }*/
    }
    
    void check() {  //检查是否死亡或者吃到食物
        int x, y, i, j;
        x = A[sum - 1].x + dx[A[sum - 1].dir];  //记录按当前方向移动一格后蛇头的坐标 
        y = A[sum - 1].y + dy[A[sum - 1].dir];
        if (map[x][y] == '*' || map[x][y] == 'X') {  //如果地图上该坐标处字符为‘*’或‘X’就死亡 
            if (x != A[0].x || y != A[0].y) {  //蛇尾除外 
                map[8][4] = 'G'; map[8][5] = 'A'; map[8][6] = 'M'; map[8][7] = 'E';  //输出“GAME OVER” 
                map[8][9] = 'O'; map[8][10] = 'V'; map[8][11] = 'E'; map[8][12] = 'R';
                map[8][8] = ' ';
                system("cls");
                for (i = 0; i < 17; i++) {
                    for (j = 0; j < 17; j++) {
                        printf("%c", map[i][j]);
                    }
                    printf("\n");
                }
                printf("Input 'r' to restart\nInput 'q' to quit\n");
                over = 1;
            }
        }
        else if (map[x][y] == 'O') {  //吃到苹果 
            sum++;  //蛇身总长加1 
            speed = ((600 - sum * 20)>100) ? (600 - sum * 20) : 100; //速度加快 
        }
    }
    
    void turn() {  //转弯
        if (_kbhit()) {
            char dir = _getch();  //读取输入的键 
            switch (dir) {  //改变方向 
            case 119: A[sum - 1].dir = (A[sum - 1].dir == 2)?2:0; break;
            case 100: A[sum - 1].dir = (A[sum - 1].dir == 3)?3:1; break;
            case 115: A[sum - 1].dir = (A[sum - 1].dir == 0)?0:2; break;
            case 97: A[sum - 1].dir = (A[sum - 1].dir == 1)?1:3; break;
            }
        }
    }
    
    /*void calculate() {  //计算并记录蛇头与食物距离
        int i = 0, x, y;
        for(i = 0; i < 4; i++) {
            if(movable[i] == 1) {  //如果该方向能走,则记录下沿该方向走一步后与食物的距离 
                x = A[sum - 1].x + dx[i];
                y = A[sum - 1].y + dy[i];
                distance[i] = abs(foodx-x)+abs(foody-y);
            } else {  //如果不能走则把距离设置为9999 
                distance[i] = 9999;
            }
        }
    }*/
    
    int main() {
        printf("'w''s''a''d'控制上下左右\n蛇越长跑得越快~~~\n");
        printf("按任意键开始\n");
        char ch = _getch();
        system("cls");
        ini();
        show();
        return 0;
    }
    

    2.智能贪吃蛇

    虽然说是智能但是可能并没有你想象中那么智能==。
    基本思路是按照上、右、下、左的顺序搜索方向,使得沿该方向前进能够靠近食物,前进过程中遇到障碍会自动绕开,可是不能避免蛇头被蛇身包围的情况。

    /*蛇越长跑得越快*/
    /*蛇能自己找食物*/
    /*作者:SGAFPZ*/
    #include <stdio.h>
    #include <windows.h>
    #include <stdlib.h>
    #include <math.h>
    //#include <unistd.h>
    #include <conio.h>
    #include <string.h>
    #include <time.h>
    void food();
    void show();
    void move();
    void turn();
    void check();
    void ini();
    void calculate();
    int movable[4] = { 0, 1, 1, 0 };  //数组的下标表示方向,0123分别表示上下左右,下同
    int distance[4] = { 9999, 9999, 9999, 9999 };
    int  dy[4] = { 0, 1, 0, -1 };
    int  dx[4] = { -1, 0, 1, 0 };
    int sum = 5;  //蛇总长度
    int over = 0;
    int speed;   
    int foodx, foody;  //食物的坐标
    char map[17][17];
    
    struct snake {
        int x, y;  //身体坐标 
        int dir;  //方向(只有蛇头的方向是有用的) 
    } A[100];
    
    void ini() {  //初始化界面
        speed = 500;
        over = 0;
        sum = 5;
        movable[0] = 0; movable[1] = 1; movable[2] = 1; movable[3] = 0;
        distance[0] = 9999; distance[1] = 9999; distance[2] = 9999; distance[3] = 9999;
        int i, j;
        for (i = 0; i < 100; i++) {  //初始化蛇头和蛇身的数据
            A[i].dir = 0;
            A[i].x = 0;
            A[i].y = 0;
        }
        A[0].x = 1; A[0].y = 1;  //地图左上角设置一条长度为5的蛇
        A[1].x = 1; A[1].y = 2;
        A[2].x = 1; A[2].y = 3;
        A[3].x = 1; A[3].y = 4;
        A[4].x = 1; A[4].y = 5; A[4].dir = 1;
        srand(time(0));
        for (i = 0; i < 17; i++) {  //设置地图
            for (j = 0; j < 17; j++) {
                map[i][j] = '*';
            }
        }
        for (i = 1; i < 16; i++) {
            for (j = 1; j < 16; j++) {
                map[i][j] = ' ';
            }
        }
        //map[6][5] = '*'; map[6][6] = '*'; map[6][7] = '*';
        //map[7][5] = '*'; map[7][7] = '*';
        map[A[4].x][A[4].y] = 'H';  //设置蛇头
        for (i = 0; i < sum - 1; i++) {  //设置蛇身
            map[A[i].x][A[i].y] = 'X';
        }
        food();
        calculate();
    }
    
    
    void show() {  //显示界面 
        int i, j, x, y;
        for (i = 0; i < 17; i++) {  //显示界面
            for (j = 0; j < 17; j++) {
                printf("%c", map[i][j]);
            }
            printf("\n");
        }
        while (1) {
            Sleep(speed);  //界面刷新速度
            turn();
            move();
            if (over) {  //设置蛇死掉后可以进行的操作 
                while (1) {
                    char ch = _getch();
                    if (ch == 113) {  //输入‘q’结束 
                        return;
                    }
                    else if (ch == 114) {  //输入‘r’重新开始 
                        ini();
                        break;
                    }
                }
            }
            system("cls");  //清屏 
            for (i = 0; i < 17; i++) {  //重新显示界面
                for (j = 0; j < 17; j++) {
                    printf("%c", map[i][j]);
                }
                printf("\n");
            }
            calculate(); //计算并记录蛇头与食物距离
        }
    }
    
    void food() {  //生成食物
        int x, y;
        while (1) {
            x = (int)(15 * rand() / (RAND_MAX + 1.0));  //随机产生一组食物坐标
            y = (int)(15 * rand() / (RAND_MAX + 1.0));
            if (map[x][y] == ' ') {  //如果是空格则在该处生成食物
                map[x][y] = 'O';
                foodx = x;  //记录食物坐标 
                foody = y;
                break;
            }
        }
    }
    
    
    void move() {  //蛇移动
        int i, x, y;
        int t = sum;  //t记录当前蛇总长度 
        check();  //移动前检查按当前方向移动一步后的情况
        if (t == sum) {  //没有吃到苹果
            for (i = 0; i < sum - 1; i++) {
                if (i == 0) {  //蛇尾坐标处变成空格,把蛇尾坐标变成前一个蛇身的坐标 
                    map[A[i].x][A[i].y] = ' ';
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                else {  //每个蛇身坐标都变为它前一个蛇身的坐标
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                map[A[i].x][A[i].y] = 'X';  //把地图上蛇身坐标处的字符设置成‘X’
            }
            A[sum - 1].x = A[sum - 1].x + dx[A[sum - 1].dir];  //蛇头按当前方向移动一格 
            A[sum - 1].y = A[sum - 1].y + dy[A[sum - 1].dir];
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
        }
        else {  //吃到苹果(sum会加1)
            map[A[sum - 2].x][A[sum - 2].y] = 'X';  //把地图上原蛇头坐标处的字符设置成‘X’
            A[sum - 1].x = A[sum - 2].x + dx[A[sum - 2].dir];  //新蛇头的坐标是原蛇头沿当前方向移动一格后的坐标 
            A[sum - 1].y = A[sum - 2].y + dy[A[sum - 2].dir];
            A[sum - 1].dir = A[sum - 2].dir;  //新蛇头方向为原蛇头的方向
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
            food();
        }
        for(i = 0; i < 4; i++) {  //记录下能走的方向
            x = A[sum - 1].x + dx[i];
            y = A[sum - 1].y + dy[i];
            if(map[x][y] == ' ' || map[x][y] == 'O') {
                movable[i] = 1;  //能走就把对应方向的值设置为1 
            } else {
                if(x != A[0].x || y != A[0].y) {
                    movable[i] = 0;  //不能走就把对应方向的值设置为0 
                } else {
                    movable[i] = 1;
                }
            }
        }
    }
    
    void check() {  //检查是否死亡或者吃到食物
        int x, y, i, j;
        x = A[sum - 1].x + dx[A[sum - 1].dir];  //记录按当前方向移动一格后蛇头的坐标 
        y = A[sum - 1].y + dy[A[sum - 1].dir];
        if (map[x][y] == '*' || map[x][y] == 'X') {  //如果地图上该坐标处字符为‘*’或‘X’就死亡 
            if (x != A[0].x || y != A[0].y) {  //蛇尾除外 
                map[8][4] = 'G'; map[8][5] = 'A'; map[8][6] = 'M'; map[8][7] = 'E';  //输出“GAME OVER” 
                map[8][9] = 'O'; map[8][10] = 'V'; map[8][11] = 'E'; map[8][12] = 'R';
                map[8][8] = ' ';
                system("cls");
                for (i = 0; i < 17; i++) {
                    for (j = 0; j < 17; j++) {
                        printf("%c", map[i][j]);
                    }
                    printf("\n");
                }
                printf("Input 'r' to restart\nInput 'q' to quit\n");
                over = 1;
            }
        }
        else if (map[x][y] == 'O') {  //吃到苹果 
            sum++;  //蛇身总长加1 
            speed = ((600 - sum * 20)>100) ? (600 - sum * 20) : 100; //速度加快 
        }
    }
    
    void turn() {  //转弯
        int i, k = 0;
        for(i = 1; i < 4; i++) {  //找到走一步后离食物距离最短的方向
            if(distance[k] > distance[i]) {
                k = i;
            }
        }
        switch (k) {  //把把蛇头方向改为该方向 
            case 0: A[sum - 1].dir = (A[sum - 1].dir == 2)?2:0; break;
            case 1: A[sum - 1].dir = (A[sum - 1].dir == 3)?3:1; break;
            case 2: A[sum - 1].dir = (A[sum - 1].dir == 0)?0:2; break;
            case 3: A[sum - 1].dir = (A[sum - 1].dir == 1)?1:3; break;
        }
    }
    
    void calculate() {  //计算并记录蛇头与食物距离
        int i = 0, x, y;
        for(i = 0; i < 4; i++) {
            if(movable[i] == 1) {  //如果该方向能走,则记录下沿该方向走一步后与食物的距离 
                x = A[sum - 1].x + dx[i];
                y = A[sum - 1].y + dy[i];
                distance[i] = abs(foodx-x)+abs(foody-y);
            } else {  //如果不能走则把距离设置为9999 
                distance[i] = 9999;
            }
        }
    }
    
    int main() {
        printf("你只需要静静地看着它跑\n");
        printf("按任意键开始\n");
        char ch = _getch();
        system("cls");
        ini();
        show();
        return 0;
    }
    
    展开全文
  • 贪吃蛇C语言

    千次阅读 2021-01-12 10:21:07
    贪吃蛇C语言 不知不觉大一已过去了一半, 我也是感慨良多, 那是我失去的青春, 呜呜呜~~ 这次代码是继上次的优化和完善, 若有好的建议或意见随时欢迎交流 运行效果图 代码奉上 # include <stdio.h> # include &...

    贪吃蛇 简易版 C语言

    开始学C两个多月, 斗胆自制贪吃蛇, 因为没有资源, 所有逻辑码字全靠自身, 如果能给大家带来新的思考和感悟, 将是我最大的荣幸----2020.12.08

    不知不觉大一已过去了一半, 今天要考试了, 我也是感慨良多, 那是我失去的青春, 呜呜呜~~ 这次代码是继上次的优化和完善, 若有好的建议或意见随时欢迎交流----2021.1.13

    看到有朋友评论, 我有点小激动, 所以又偷偷优化一下代码, 最近开始进攻Java, 希望能在一周之内拿下----2021.1.18

    运行效果图在这里插入图片描述

    代码奉上

    # include <stdio.h>
    # include <stdlib.h> 					//malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()
    # include <windows.h>					//Sleep()、gotoxy()、HideCursor()
    # include <conio.h>						//_getch()、kbhit()
    # include <time.h>						//time()
    
    //**************************************//光标
    
    void gotoxy(int x, int y) {				//移动光标; 网上复制
    	COORD pos;
    	HANDLE hOutput;
    	pos.X = (SHORT)x;
    	pos.Y = (SHORT)y;
    	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    	SetConsoleCursorPosition(hOutput, pos);
    }
    
    void HideCursor() {						//隐藏光标; 网上复制
    	CONSOLE_CURSOR_INFO cursor;
    	cursor.bVisible = FALSE;
    	cursor.dwSize = sizeof(cursor);
    	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    	SetConsoleCursorInfo(handle, &cursor);
    }
    
    //**************************************//全局变量
    
    int length = 5, x = 5, y = 5, fx = 5, fy = 5;//length蛇身长度; (x, y)蛇身坐标; (fx, fy)食物坐标;
    
    //**************************************//墙体
    
    void Wall() {							//打印墙体, 长40, 宽20
    	gotoxy(0, 0);
    	for (int i = 0; i < 20; ++i) {
    		for (int j = 0; j < 40; ++j) {
    			if (0 == i || 19 == i || 0 == j || 39 == j) {
    				printf("*");
    			} else {
    				printf(" ");
    			}
    		}
    		printf("\n");
    	}
    }
    
    void GameOver() {                       //游戏结束
    	gotoxy(0, 0);
    	Wall();                             //覆盖蛇身
    	gotoxy(15, 9);
    	puts("GAME OVER");
    	system("pause");
    	exit(0);
    }
    
    void WallDeath() {                      //撞墙结束
    	if (0 == x || 39 == x || 0 == y || 19 == y) {
    		GameOver();
    	}
    }
    
    //**************************************//结构体
    
    typedef struct Node {                 	//坐标结构体
    	int x, y;
    	struct Node *next;
    } Node, *List;
    
    List head; 								//head不是蛇头坐标, head->next才是蛇头坐标
    
    List Create() { 						//创建结点
    	List p = (List)malloc(sizeof(Node));
    	p->next = NULL;
    	return p;
    }
    
    void Insert() { 						//录入结点
    	List p = Create();
    	p->x = x;
    	p->y = y;
    	p->next = head->next;
    	head->next = p;
    }
    
    //**************************************//食物
    
    List RandCreate() {                     //产生随机坐标
    	List p = Create();
    	srand((unsigned)time(NULL));      
    	p->x = rand() % 38 + 1;
    	p->y = rand() % 18 + 1;
    	return p;
    }
    
    List FoodCreate() {                     //产生食物
    	List p = head->next;            	//蛇身
    	List pFood = Create();              //食物
    	int flag = 0;
    	while (1) {
    		flag = 0;
    		pFood->x = RandCreate()->x;     //新的食物坐标
    		pFood->y = RandCreate()->y;
    		//食物坐标与蛇身坐标比较, 如果相同, 则重新产生食物
    		for (int i = 0; i < length && p; ++i, p = p->next) {
    			if (pFood->x == p->x && pFood->y == p->y) {
    				flag = 1;
    				break;
    			}
    		}
    		if (0 == flag) {
    			return pFood;
    		}
    	}
    }
    
    void FoodEat() {						//吃到食物
    	if(x == fx && y == fy) {
    		++length;                       //长度+1
    		fx = FoodCreate()->x;
    		fy = FoodCreate()->y;
    		gotoxy(fx, fy);
    		printf("$");                    //打印新食物
    	}
    }
    
    //**************************************蛇身
    
    void EatOver() {                    	//吃到自己
    	List pHead = head->next;            //蛇头坐标
    	List p = pHead->next;
    	//比较头坐标与身体坐标, 如果重合, 即撞到自身, 游戏结束
    	for (int i = 0; i < length && p; ++i, p = p->next) {
    		if (pHead->x == p->x && pHead->y == p->y) {
    			GameOver();
    		}
    	}
    }
    
    void Print() { 							//打印蛇身
    	EatOver();                          //是否吃到自己
    	List p = head->next;
    	for (int i = 0; i < length && p->next; ++i, p = p->next) {
    		gotoxy(p->x, p->y);
    		if (0 == i) {                   //蛇头
    			printf("@");
    		} else if (1 == i) {            //蛇身
    			printf("+");
    		} else if (i == length - 1) {   //蛇尾覆盖
    			printf(" ");
    		}
    	}
    	free(p->next);						//及时释放空间
    	p->next = NULL;
    }
    
    //**************************************//主函数
    
    int main() {
    	HideCursor();                       //隐藏光标
    	Wall();                             //打印墙体
    	head = Create();
    	gotoxy(fx, fy);                     //打印第一个食物
    	printf("$");
    	DWORD speed = 200;                  //移动速度, 可自己设置
    	char ch;                            //方向
    	while (1) {                         //有按键键入则改变方向
    		ch = (char)getch();
    		while (!kbhit()) {            	//无按键键入则继续移动
    			switch (ch) {
    				case 'a': {             //向左
    					--x;
    					break;
    				}
    				case 'd': {             //向右
    					++x;
    					break;
    				}
    				case 'w': {             //向上
    					--y;
    					break;
    				}
    				case 's': {             //向下
    					++y;
    					break;
    				}
    				default: {
    					break;
    				}
    			}
    			FoodEat();                  //吃到食物
    			WallDeath();            	//撞墙
    			Insert();                   //录入
    			Print();                    //打印
    			Sleep(speed);               //速度
    		}
    	}
    
    	return 0;
    }
    

    码字不易, 不喜勿喷; 如有高见, 欢迎留言-

    展开全文
  • c语言 贪吃蛇贪吃蛇 c语言贪吃蛇c语言 贪吃蛇贪吃蛇 c语言贪吃蛇c语言 贪吃蛇贪吃蛇 c语言贪吃蛇
  • 贪吃蛇c语言版.cpp

    2020-09-07 21:39:05
    贪吃蛇C语言版本++++
  • window下的贪吃蛇C语言代码
  • 贪吃蛇C语言程序设计

    2013-02-27 14:22:05
    贪吃蛇C语言程序设计
  • 贪吃蛇c语言 vc6.0实现

    2019-01-13 17:07:35
    贪吃蛇c语言 vc6.0实现,运用指针数组简单易懂,可扩展功能,可扩展推箱子,俄罗斯方块等。大二自学小游戏项目。键盘控制方向实现移动,打印不同符号实现地图,蛇和食物。易懂便于学习
  • 贪吃蛇C语言程序代码,超级好玩,感谢下载感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢感谢
  • 主要为大家详细介绍了贪吃蛇C语言代码实现,游戏难度可供选择,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 贪吃蛇 C语言程序

    2018-06-25 18:06:04
    可用贪吃蛇程序,C语言实现,简单易于理解 ,亲测可用
  • 贪吃蛇C语言源代码,包含手机和电脑版,电脑版包含.exe执行文件,手机可以自行编译
  • 游戏分析:——初期分析蛇:考虑到每个蛇节点包含x,y坐标以及指向下一个节点的指针(坐标用c语言内置类型COORD,本质是一个由x和y坐标构成的结构体类型),用结构体类型来表示每一个蛇身节点;坐标:c语言有内置的...

    bf7adb75785b89cbb9adae43ffbe49e7.png

    游戏分析:

    ——初期分析

    1. 蛇:考虑到每个蛇节点包含x,y坐标以及指向下一个节点的指针(坐标用c语言内置类型COORD,本质是一个由x和y坐标构成的结构体类型),用结构体类型来表示每一个蛇身节点;
    2. 坐标:c语言有内置的坐标结构体类型,包括x和y坐标,一个坐标对应一个字符的大小,一个方形x方向占两个字符,即两个x坐标,y方向占一个;
    3. 光标位置,用一个Pos函数来移动光标到指定位置完成打印输出;
    4. 生成小蛇;
    5. 随机出现食物:食物的出现不能超出坐标边界,使用srand和rand方法生成随机食物;在生成食物的时候注意由于一开始的x坐标出现在偶数上,所以rand得到的食物的x坐标也必须是偶数,否则蛇吃不到,y坐标没有限制;
    6. 蛇移动,寻找食物:程序的核心,每次蛇的移动都是在响应一个移动事件,在每两次移动事件之间加上时间延缓来使蛇的移动看起来自然。当然可以通过加速和减速功能来减小或者增加延缓时间。如果蛇吃到食物,把食物节点作为新的头节点,后面的节点位置不动。否则把食物作为头节点,后面的节点依次前移,末尾节点设为空并刷新。
    7. 碰墙,碰自己,用户返回,游戏结束。

    ——几大模块

    一 ,初始化模块(init.h):

      功能分析:

          初始化欢迎界面:

      初始化地图

      初始化蛇身

      具体实现:

          初始化欢迎界面:定位好坐标并打印相关欢迎信息即可;

      初始化地图:定位好坐标并依次打印出方块即可;

      初始化蛇身:先生成一个节点,再自左向右依次设置剩下的节点,最后遍历打印出节点(方块);

    二:判断模块(judge.h):

        功能分析:

             判断是否碰墙

       判断是否碰到自己

      判断游戏是否结束(通过标志位)

       具体实现:

            判断是否碰墙:如果蛇头坐标超出地图范围,判定为撞墙,修改游戏结束标志位;

            判断是否碰到自己:从头部开始遍历蛇,如果哪个节点坐标和头部节点坐标重合,就判断撞到自己;

            判断游戏是否结束(通过标志位):根据标志位的状态判断游戏是否结束;

    三:游戏模块(snake.cpp):

    功能分析:

            随机出现食物

      玩家操作蛇移动,每次响应一个输入事件

      游戏结束

    具体实现:

            随机出现食物:每次通过rand函数生成一个随机坐标,把x转化为偶数坐标,y不变,然后把光标移动到对应位置打印出食物;

            玩家操作蛇移动,每次响应一个键盘输入事件:游戏核心,每次响应移动事件后判断是否吃到食物:

          1. 吃到食物:把食物节点作为新的头节点,其余节点位置不变,游戏分数加point;
          2. 没吃到食物,把新开的后继节点作为新的头节点,剩余节点依次向前移动;这样原来的最后一个节点就成为了空节点,打印出空格来覆盖原来的方块。

            游戏结束:结束游戏。

    代码如下:

    1 // 定义蛇身节点
      2 typedef struct SNAKE{
      3     int x;
      4     int y;
      5     struct SNAKE*next;
      6 }snake;
      7 snake *head;    //头指针
      8 //设置光标位置
      9 void Pos(int x, int y)
     10 {
     11     //坐标类型结构体
     12     COORD pos;
     13     pos.X = x;
     14     pos.Y = y;
     15     //定义并初始化句柄
     16     HANDLE Houtput = GetStdHandle(STD_OUTPUT_HANDLE);
     17     //设置光标位置
     18     SetConsoleCursorPosition(Houtput, pos);
     19 }
     20 
     21 void SetColor(int color_num) //需包含头文件windows.h
     22 {
     23     using namespace std;
     24     HANDLE color; //声明一个句柄
     25     color = GetStdHandle(STD_OUTPUT_HANDLE); //取得标准输出句柄
     26     SetConsoleTextAttribute(color, color_num);
     27     //设置颜色函数SetConsoleTextAttribute有两个参数,第一个为句柄,第二个为颜色代表值 
     28     //可以使用「|」在第二个参数所填颜色间隔开,实现混色
     29 }
     30 
     31 //欢迎界面
     32 void welcomepage()
     33 {
     34     Pos(40, 12);
     35     SetColor(6);
     36     printf("~~欢迎来到贪吃蛇游戏~~");
     37     Pos(40, 25);
     38     printf("用↑,↓,←,→控制蛇的移动n");
     39     system("pause");
     40     system("cls");
     41 }
     42 //初始化地图58/2=29列26行
     43 void Map_create()
     44 {
     45     int i;
     46     //■占两个字符的位置(光标移动一位对应一个字符,两个字符光标每次移动两位,也就是坐标值每次加2,一个坐标值对应一个字符位)
     47     //上下 
     48     for (i = 0; i < 58; i += 2)
     49     {
     50         //移动光标
     51         Pos(i, 0);
     52         SetColor(4);
     53         printf("■");
     54         Pos(i, 26);
     55         SetColor(6);
     56         printf("■");
     57     }
     58     //左右    y取1,2,3...25
     59     for (i = 0; i < 26; i++)
     60     {
     61         //移动光标
     62         Pos(0, i);
     63         SetColor(4);
     64         printf("■");
     65         Pos(56, i);
     66         SetColor(6);
     67         printf("■");
     68     }
     69     printf("n");
     70 }
     71 
     72 //初始化蛇身,x,y坐标的取值范围57和25
     73 void Snakeinit()
     74 {
     75     snake *tail;    //尾指针
     76     int i;
     77     tail = (snake*)malloc(sizeof(snake));    //初始化尾指针,采用头插法
     78     tail->x = 24;    //这个设定注定头节点的x坐标只能是偶数
     79     tail->y = 5;    //y坐标任意
     80     tail->next = NULL;
     81     //生成五节长的小蛇
     82     for (i = 1; i <= 4; i++)
     83     {
     84         //生成头指针,每次将头指针赋值给尾指针,使蛇增加一节,前面的节已经链在了链表中
     85         head = (snake*)malloc(sizeof(snake));
     86         head->next = tail;
     87         head->x = 24 + 2 * i;
     88         head->y = 5;
     89         tail = head;
     90     }
     91     //从头部开始打印小蛇
     92     while (tail != NULL)
     93     {
     94         //修改光标
     95         Pos(tail->x, tail->y);
     96         SetColor(2);
     97         printf("■");
     98         tail = tail->next;
     99     }
    100 
    101 
    102 }
    
    init.h
    1 int gameoverflag = 0; //游戏分三种情况,1:撞到墙;2:咬到自己;3:主动退出游戏。
     2 int score = 0, point = 10;//总得分与每次吃食物得分。
     3 
     4 int biteself()//判断是否咬到了自己
     5 {
     6     snake *self;
     7     self = head->next;
     8     while (self != NULL)
     9     {
    10         if (self->x == head->x && self->y == head->y)
    11         {
    12             return 1;
    13         }
    14         self = self->next;
    15     }
    16     return 0;
    17 }
    18 
    19 
    20 void endgame()//结束游戏
    21 {
    22 
    23     system("cls");
    24     Pos(24, 12);
    25     if (gameoverflag== 1)
    26     {
    27         printf("对不起,您撞到墙了。游戏结束.");
    28     }
    29     else if (gameoverflag == 2)
    30     {
    31         printf("对不起,您咬到自己了。游戏结束.");
    32     }
    33     else if (gameoverflag== 3)
    34     {
    35         printf("您的已经结束了游戏。");
    36     }
    37     Pos(24, 13);
    38     printf("您的得分是%dn", score);
    39     exit(0);
    40 }
    41 
    42 
    43 void cantcrosswall()//不能穿墙
    44 {
    45     if (head->x == 0 || head->x == 56 || head->y == 0 || head->y == 26)
    46     {
    47         gameoverflag = 1;
    48         endgame();
    49     }
    50 }
    51 
    52 void game_pause()//暂停
    53 {
    54     while (1)
    55     {
    56         Sleep(300);
    57         if (GetAsyncKeyState(VK_SPACE))
    58         {
    59             break;
    60         }
    61 
    62     }
    63 }
    
    judge.h
    1 #include<stdio.h>
      2 #include<time.h>
      3 #include<windows.h>
      4 #include<stdlib.h>
      5 #include "init.h"
      6 #include "judge.h"
      7 
      8 #define U 1
      9 #define D 2
     10 #define L 3 
     11 #define R 4 //蛇的状态,U:上 ;D:下;L:左 R:右
     12 
     13 
     14 
     15 //全局变量//
     16 int status, sleeptime = 200;//蛇每次移动的时间间隔200ms
     17 snake *food;//食物指针
     18 snake *q;//遍历蛇的时候用到的指针
     19 
     20 
     21 
     22 void createfood()//随机出现食物
     23 {
     24     snake *food_1;
     25     srand((unsigned)time(NULL));
     26     //初始化x坐标
     27     food_1 = (snake*)malloc(sizeof(snake));
     28     while ((food_1->x % 2) != 0) //保证其为偶数,使得食物能与蛇头对其
     29     {
     30         food_1->x = rand() % 52 + 2;
     31     }
     32     food_1->y = rand() % 24 + 1;
     33     q = head;
     34     while (q->next == NULL)
     35     {
     36         if (q->x == food_1->x && q->y == food_1->y) //判断蛇身是否与食物重合
     37         {
     38             free(food_1);
     39             createfood();
     40         }
     41         q = q->next;
     42     }
     43     Pos(food_1->x, food_1->y);
     44     food = food_1;
     45     SetColor(4);
     46     printf("■");
     47 }
     48 
     49 
     50 
     51 void snakemove()//蛇前进,上U,下D,左L,右R
     52 {
     53     snake * nexthead;
     54     cantcrosswall();
     55 
     56     nexthead = (snake*)malloc(sizeof(snake));
     57     if (status == U)
     58     {
     59         nexthead->x = head->x;
     60         nexthead->y = head->y - 1;
     61         if (nexthead->x == food->x && nexthead->y == food->y)//如果下一个有食物//
     62         {
     63             nexthead->next = head;
     64             head = nexthead;
     65             q = head;
     66             while (q != NULL)
     67             {
     68                 Pos(q->x, q->y);
     69                 SetColor(6);
     70                 printf("■");
     71                 q = q->next;
     72             }
     73             score = score + point;
     74             createfood();
     75         }
     76         else //如果没有食物//
     77         {
     78             nexthead->next = head;
     79             head = nexthead;
     80             q = head;
     81             while (q->next->next != NULL)
     82             {
     83                 Pos(q->x, q->y);
     84                 SetColor(9);
     85                 printf("■");
     86                 q = q->next;
     87             }
     88             Pos(q->next->x, q->next->y);
     89             printf(" ");
     90             free(q->next);
     91             q->next = NULL;
     92         }
     93     }
     94     if (status == D)
     95     {
     96         nexthead->x = head->x;
     97         nexthead->y = head->y + 1;
     98         if (nexthead->x == food->x && nexthead->y == food->y) //有食物
     99         {
    100             nexthead->next = head;
    101             head = nexthead;
    102             q = head;
    103             while (q != NULL)
    104             {
    105                 Pos(q->x, q->y);
    106                 SetColor(6);
    107                 printf("■");
    108                 q = q->next;
    109             }
    110             score = score + point;
    111             createfood();
    112         }
    113         else //没有食物
    114         {
    115             nexthead->next = head;
    116             head = nexthead;
    117             q = head;
    118             while (q->next->next != NULL)
    119             {
    120                 Pos(q->x, q->y);
    121                 SetColor(12);
    122                 printf("■");
    123                 q = q->next;
    124             }
    125             Pos(q->next->x, q->next->y);
    126             printf(" ");
    127             free(q->next);
    128             q->next = NULL;
    129         }
    130     }
    131     if (status == L)
    132     {
    133         nexthead->x = head->x - 2;
    134         nexthead->y = head->y;
    135         if (nexthead->x == food->x && nexthead->y == food->y)//有食物
    136         {
    137             nexthead->next = head;
    138             head = nexthead;
    139             q = head;
    140             while (q != NULL)
    141             {
    142                 Pos(q->x, q->y);
    143                 SetColor(6);
    144                 printf("■");
    145                 q = q->next;
    146             }
    147             score = score + point;
    148             createfood();
    149         }
    150         else //没有食物
    151         {
    152             nexthead->next = head;
    153             head = nexthead;
    154             q = head;
    155             while (q->next->next != NULL)
    156             {
    157                 Pos(q->x, q->y);
    158                 SetColor(14);
    159                 printf("■");
    160                 q = q->next;
    161             }
    162             Pos(q->next->x, q->next->y);
    163             printf(" ");
    164             free(q->next);
    165             q->next = NULL;
    166         }
    167     }
    168     if (status == R)
    169     {
    170         nexthead->x = head->x + 2;
    171         nexthead->y = head->y;
    172         if (nexthead->x == food->x && nexthead->y == food->y)//有食物
    173         {
    174             nexthead->next = head;
    175             head = nexthead;
    176             q = head;
    177             while (q != NULL)
    178             {
    179                 Pos(q->x, q->y);
    180                 SetColor(6);
    181                 printf("■");
    182                 q = q->next;
    183             }
    184             score = score + point;
    185             createfood();
    186         }
    187         else //没有食物
    188         {
    189             nexthead->next = head;
    190             head = nexthead;
    191             q = head;
    192             while (q->next->next != NULL)
    193             {
    194                 Pos(q->x, q->y);
    195                 SetColor(6);
    196                 printf("■");
    197                 q = q->next;
    198             }
    199             Pos(q->next->x, q->next->y);
    200             printf(" ");
    201             free(q->next);
    202             q->next = NULL;
    203         }
    204     }
    205     if (biteself() == 1) //判断是否会咬到自己
    206     {
    207         gameoverflag = 2;
    208         endgame();
    209     }
    210 }
    211 
    212 
    213 //玩游戏
    214 void gameplay()
    215 {
    216 
    217     Pos(64, 15);
    218     SetColor(6);
    219     printf("不能穿墙,不能咬到自己n");
    220     Pos(64, 16);
    221     SetColor(7);
    222     printf("用↑.↓.←.→分别控制蛇的移动.");
    223     Pos(64, 17);
    224     SetColor(8);
    225     printf("F1 为加速,F2 为减速n");
    226     Pos(64, 18);
    227     SetColor(9);
    228     printf("ESC :退出游戏.space:暂停游戏.");
    229     Pos(64, 20);
    230     SetColor(10);
    231     printf("~~**~~");
    232     status = R;
    233     while (1)
    234     {
    235         Pos(64, 10);
    236         printf("得分:%d ", score);
    237         Pos(64, 11);
    238         printf("每个食物得分:%d分", point);
    239         if (GetAsyncKeyState(VK_UP) && status != D)
    240         {
    241             status = U;
    242         }
    243         else if (GetAsyncKeyState(VK_DOWN) && status != U)
    244         {
    245             status = D;
    246         }
    247         else if (GetAsyncKeyState(VK_LEFT) && status != R)
    248         {
    249             status = L;
    250         }
    251         else if (GetAsyncKeyState(VK_RIGHT) && status != L)
    252         {
    253             status = R;
    254         }
    255         else if (GetAsyncKeyState(VK_SPACE))
    256         {
    257             game_pause();
    258         }
    259         else if (GetAsyncKeyState(VK_ESCAPE))
    260         {
    261             gameoverflag = 3;
    262             endgame();
    263         }
    264         //加速,就是缩小两次移动事件之间的响应速度(反应时间)
    265         else if (GetAsyncKeyState(VK_F1))
    266         {
    267             if (sleeptime >= 50)
    268             {
    269                 //每次减去30ms
    270                 sleeptime = sleeptime - 30;
    271                 //加速奖励分,以后吃到食物多加分
    272                 point = point + 2;
    273             }
    274         }
    275         //减速,就是增加两次移动事件之间的响应速度(反应时间)
    276         else if (GetAsyncKeyState(VK_F2))
    277         {
    278             if (sleeptime<350)
    279             {
    280                 sleeptime = sleeptime + 30;
    281                 //减速难度下降,以后吃到食物分减少
    282                 point= point- 2;
    283                 if (sleeptime == 350)
    284                 {
    285                     point= 1; //保证最低分为1
    286                 }
    287             }
    288         }
    289         //刷新事件,两次事件之间间隔sleeptime的毫秒
    290         Sleep(sleeptime);
    291         snakemove();
    292     }
    293 }
    294 
    295 
    296 
    297 void game_init()//游戏初始化
    298 {
    299     system("mode con cols=100 lines=30");
    300     welcomepage();
    301     Map_create();
    302     Snakeinit();
    303     createfood();
    304 }
    305 
    306 int main()
    307 {
    308     //初始化游戏
    309     game_init();
    310     //开始玩游戏
    311     gameplay();
    312     return 0;
    313 }
    
    snack.cpp

    学习资料分享交流群:1093734341 入群有全套学习视频资料电子书免费赠送!

    资料:

    物联网开发入门直播课 - 嵌入式/物联网-C语言编程基础www.makeru.com.cnC语言_嵌入式www.makeru.com.cn
    e69376feb027b9f28fd702c598bd1268.png
    嵌入式开发直播课 - 带你提升C编程能力www.makeru.com.cn
    1170a285ac3ca66061ce328a48e0a1d5.png
    嵌入式底层开发 - 夯实C语言,从小白到大牛的进阶之路!www.makeru.com.cn
    1170a285ac3ca66061ce328a48e0a1d5.png
    展开全文
  • 基于51单片机的3216点阵贪吃蛇C语言源代码。另附proturs仿真原理图。
  • 基于51单片机的3216点阵贪吃蛇C语言源代码。另附proturs仿真原理图。
  • 课程设计贪吃蛇c语言

    2020-11-06 18:01:58
    大学c语言课程设计,下载后粘贴到codeblocks里即可直接使用,有速度调节功能,积分功能,排行榜功能等,
  • 1.贪吃蛇C语言实现。代码主要来自Bilibili某C语言贪吃蛇教学视频,但由于时间过长,播放历史已无从寻找。(不想作为下载浪费大家的积分,但如果你觉得不错的话,偏要给我我也不好意思不收:审核还没过等会) 2.代码...

    前言

    1.贪吃蛇C语言实现。代码主要来自Bilibili某C语言贪吃蛇教学视频,但由于时间过长,播放历史已无从寻找。(不想作为下载浪费大家的积分,但如果你觉得不错的话,偏要给我我也不好意思不收:审核还没过等会)
    2.代码还有待完善,现在上传的是基本功能都完善的版本。其中pausemenu等函数尚且需要完善。

    主要代码

    /*
    1.数据设计
    2.模块化设计
    3.实现功能
    
    /
    //								贪吃蛇 
    //                          编写 20190818   bug:蛇撞左右墙不死
    */				//			改写 20191002   20190818bug未修复 原因未知
    /*                          修复 20191228   20190818bug修复                                       */
    
    
    #include<stdio.h>
    #include<windows.h>
    #include<conio.h>
    #include<stdlib.h>
    #include<time.h>
    #include<iostream>
    辅助宏定义
    #define	MAPHEIGHT 20   //高度
    #define MAPWIDTH 30	 //宽度
    #define MAXSIZE 30	//最大长度
    
    using namespace std;					
    
    
    //数据设计
    //								食物
    struct Food
    {  int x,y;	//坐标定位
    
    
    }food;
    //								蛇
    struct Snake	// 每一节蛇的 坐标
    {  int x[MAXSIZE];
       int y[MAXSIZE];
    	int len;
    	int speed;
    
    
    
    		
    }snake;
    
    /
    /全局变量
    int key_last = 'w' ;	 //上次运动初始方向
    int key_next='w';		  //新的运动方向
    int changeflag  = 0;//运动方向改变标志
    
    //模块化设计  --》功能划分--》》抽象到函数
    									
    										
    //1.画地图
    void drawmap();
    //2. 食物
    void creatfood();
    //3.按键操作
    void KeyDown();
    //4.蛇的状态
    int snakestatus();
    //5.辅助函数 光标移动
    void gotoxy(int x,int y);
    	
    void pausemenu();
    
    
    int main ()
    {
    //	gotoxy(1,1);
    	drawmap();
    	
    	while (1)
    	{		creatfood();
    			Sleep(snake.speed*2);
    			KeyDown(); 
    			if(!snakestatus())
    				{
    					break;
    				}  
    	}
    	gotoxy(MAPWIDTH/2-4,MAPHEIGHT/2);
    	printf("Game over!\t");
    	
    	system("pause");
    		
    return 0;
    }  
    
    	
    void gotoxy(int x,int y)
    {
     //调用win32的API 去设置控制台的光标位置
    //1.找到控制台窗口
    	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    //2.光标的结构体
    	COORD coord;
    //3.设置坐标 光标
    	coord.X=x;
    	coord.Y=y;
    //4.同步到控制台
    	SetConsoleCursorPosition(handle,coord);
    
    
    			
    
    }
    void drawmap()
    {  	
    //⚪	  + 
    	//int height=40,width=30;
       //1.圈地
    	for(int i=0;i<=MAPHEIGHT;i++)
    	{
    		gotoxy(0,i);
    		printf("■");
    		gotoxy(MAPWIDTH,i);
    		printf("■");
    	}
    
    	for(int j=2 ;j<=MAPWIDTH;j+=2)
    	{
    		gotoxy(j,0);
    		printf("■");
    		gotoxy(j,MAPHEIGHT);
    		printf("■");
    	
    	}		
    	//2.画蛇					
    	//2.1蛇的属性
    	snake.len=3;
    	snake.speed=100;
    	snake.x[0]=MAPWIDTH/2;		//蛇头置于屏幕中间
    	snake.y[0]=MAPHEIGHT/2;
    	//蛇头
    	gotoxy(snake.x[0],snake.y[0]);
    	printf("■");
    	//蛇身体
    	for(int k=1;k<snake.len;k++)
    	{
    		snake.x[k]=snake.x[k-1]+2;
    		snake.y[k]=snake.y[k-1];
    		gotoxy(snake.x[k],snake.y[k]);
    		printf("■");
    	}	
    
    	
    	//3.画食物
    	//3.1 坐标 
    		
    		while(1)
    		{ 
    			int flag=1;
    			srand((unsigned int)time(NULL));//随机函数种子
    			food.x=rand()%((MAPWIDTH-4))+2;
    			food.y=rand()%((MAPHEIGHT-2))+1;		
    			//不能在蛇的身上
    			for(int k=0 ;k<snake.len;k++)
    				{
    					if(snake.x[k]==food.x && snake.y[k]== food.y)  //食物在蛇的身上
    						{
    							flag=0;								   //标志置于0 ,即食物位置不对,需要重来
    						}
    				}
    			/*if(food.x%2!=0)
    						 {
    					//	food.x+=1;				  	//食物位置正确		而且 食物在偶数位置
    				//		break;
    						}	  */
    			if(flag&&(food.x!=2&&food.x!=MAPWIDTH-2||food.x!=1||food.x!=MAPHEIGHT-1)&&food.x%2!=0)	//位置正确	且食物不在墙里	
    						{
    						break;	
    						}				
    		}  
    	//3.2 画画
    		gotoxy(food.x,food.y);
    		printf("●");	
    		
    }
    void creatfood()
    {	//食物被吃
    	if(food.x==snake.x[0]&&food.y==snake.y[0])	  //说明食物被吃掉
    	{
    		//随机种子
    		 srand((unsigned int)time(NULL));
    		//产生的食物不能在蛇的身上
    		//食物坐标应该是偶数  否则会只能吃一半
    		while(1)
    		{
    			int flag = 1;
    				 //准备产生新的食物
    			food.x=rand()%(MAPWIDTH-4)+2;
    			food.y=rand()%(MAPHEIGHT-2)+1;		
    		//不能在蛇的身上
    			for(int k=0 ;k<snake.len;k++)
    				{
    					if(snake.x[k]==food.x && snake.y[k]== food.y)  //食物在蛇的身上
    						{
    							flag=0;								   //标志置于0 ,即食物位置不对
    						}
    				}
    			
    			if(flag&&food.x%2!=0)		//食物位置正确		而且 食物在偶数位置			  ????		food.x%2!=0	成功???
    				{
    					break;	
    				}
    		}
    	
    	gotoxy(food.x,food.y);
    	printf("●"); 	 //⊙⊙⊙⊙▇
    	snake.len++;
    	changeflag=1;//不执行擦除尾巴操作		即长度增加
    	}
        
    		
    }	  
    //3.按键操作
    void  KeyDown()
    {
      //如果按下
    	if(_kbhit())
    	{
    		fflush(stdin);
    		key_next = _getch();	
    
    	}
    ///擦除之前的蛇  的尾巴
    	if(!changeflag)//如果方向不变 擦除之前的蛇  的尾巴
    	{
    		gotoxy(snake.x[snake.len-1],snake.y[snake.len-1]);
    		printf("  ");
    	}
    	 //其他蛇身
    	for(int i =snake.len-1 ;i>0;i--)
    	{
    		snake.x[i]=snake.x[i-1];
    		snake.y[i]=snake.y[i-1];
    	}
    	 
    
    	//如果有 按下
    
    	//移动方向有变化
    
    	switch (key_next)
    	{
    		case 'w':
    		case 'W':
    	
    			snake.y[0]--;
    	
    			key_last=key_next;
    			break;
    		case 'a':
    		case 'A':
    			
    			snake.x[0]-=2;
    			key_last=key_next;
    			break;
    		case 's':
    		case 'S':
    		
    			snake.y[0]++;
    			key_last=key_next;
    			break;
    		case 'D':
    		case 'd':
    		
    			snake.x[0]+=2; //一个符号横向占两个字符	
    			key_last=key_next;
    			break;
    		case 27:
                
                
                pausemenu();			
    			break;
    		
    		}
    	
    	gotoxy(snake.x[0],snake.y[0]);//new snake head position
    	printf("■");				//draw new snake head
    	changeflag=0;	   //方向改变标志reset
    	gotoxy(MAPHEIGHT+2,0); //移动光标到头
    	//否则移动方向无变化
    	//则方向不变 keynext =keylast 
    	
    	
    }	
    //4.蛇的状态
    int snakestatus()
    {	  
    			   //4.2蛇不能撞到墙壁
    			if(snake.x[0]==1||snake.x[0]==MAPWIDTH-1||snake.y[0]==0||snake.y[0]==MAPHEIGHT)	//将	 snake.x[0]==0
    			{						//只有当snake.x[0]为奇数时才判断为真							// snake.x[0]==MAPWIDTH	
    				return 0;			//但snake.x[0]不可能为奇数									//	修改 snake.x[0]==1
    			 }																			  // snake.x[0]==MAPWIDTH-1
    		 //4.1蛇不能撞到自己	的身体													//bug修复完成
    			for(int k=2;k<snake.len;k++)
    			{
    				if(snake.x[0]==snake.x[k]&&snake.y[0]==snake.y[k])
    					return 0;	//失败			
    		
    			}						
    		//	if(snake.x[0]==snake.x[1]&&snake.y[0]==snake.y[1])return 1;
    
    			
    			//蛇不能倒退 否则无效
       return 1;			
    }
    
    
    void pausemenu()
    {
                
                //保存数据:蛇的长度和坐标位置
                FILE *fp=NULL;
                fp=fopen("C:\\Users\\Administrator\\Documents\\Visual Studio 2012\\Projects\\Snake\\Project4\\SnakeLenth.txt","w+");
                char ch1[]={(char)snake.len};     //const char ch[]="1";
                fputs(ch1 ,fp);
                fclose(fp);
                FILE *fpf=NULL;
                fpf=fopen("C:\\Users\\Administrator\\Documents\\Visual Studio 2012\\Projects\\Snake\\Project4\\SnakeLocation.txt","w+");
                        for(int i=0;snake.len>i;i++)
                            {
                            char ch2[]={(char)snake.x[i]};
                            fputs(ch2,fp);
                            
                            char ch3[] = {(char)snake.y[i]};
                            fputs(ch3,fp);
                            }
                fclose(fpf);
                system("pause");//首先暂停
                //gotoxy(MAPWIDTH/2-4,MAPHEIGHT/2);
    	        cout<<"******************************************************\t\n";
    	        cout<<"                                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"       0。继续游戏                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"       1。退出游戏                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"       2。保存存档                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"                                                        \n";
    	        cout<<"******************************************************\t\n";
    	        
                char ch;
                cin>>ch;
                switch (ch)
                    {
                    case '0':
                        break;
    
                    case '1':
                        exit(0);
                        break;
                    case '2':
                    default:
                        break;
                    }
            
    	
    }
    
    展开全文
  • 贪吃蛇 C语言 源代码

    2017-06-12 10:10:47
    贪吃蛇源代码及程序,使用C语言和EasyX图形库开发
  • C语言实现的贪吃蛇小游戏,界面美观,功能齐全,用cmd界面输出图像用键盘控制上下左右,适合入门新手学习
  • 高性能的贪吃蛇C语言实现

    千次阅读 2017-07-22 10:07:57
    高性能的贪吃蛇C语言实现(西安微易码科技暑期项目实训课程)  贪吃蛇是一个非常火爆的经典的小游戏,由于其实现起来较为简单,而且对界面的要求程度不高,经常被初学者当做提升自身编程能力的一个例子,而且由于它...
  • 贪吃蛇c语言代码

    2020-09-20 08:45:55
    贪吃蛇代码 c语言写法 //------------------------------------------problm区------------------------------ //①思考typedef 定义的变量如何利用fwrite进行存储 //②典型可利用sleep()语句类实现控制移动速度 //...
  • 贪吃蛇c语言代码.pdf

    2020-07-28 04:56:55
    贪吃蛇 c 语言代码 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <dos.h> #define NULL 0 #define UP 18432 #define DOWN 20480 #define LEFT 19200 #define RIGHT 19712 #define ESC ...
  • 贪吃蛇C语言代码.txt

    2020-03-29 11:12:07
    贪吃蛇的代码,有加速减速的控制键,也有自己可以修改操作的空间,代码可以随意修改,大神们如有改进希望能分享。
  • 贪吃蛇C语言代码(window版本)

    千次阅读 2017-08-04 01:47:49
    应李老先生要求,特熬夜写此篇贪吃蛇C语言代码,代码如下:#include #include #include #include #include <stdlib.h>// N代表长,M代表宽,其它宏定义代表对应的特定物体的字符表示。 #define N 20 #define M ...
  • 贪吃蛇随便玩玩 。。。
  • 贪吃蛇 C语言版本

    2021-01-24 10:41:10
    #include<stdafx.h> //vc自带头文件 #include<stdio.h> //标准输入输出函数库 #include<time.h> //用于获得随机数 #include<windows.h> //控制dos界面 ... //即standard library标志...
  • 贪吃蛇C语言代码 手动贪吃蛇 智能贪吃蛇 1.手动贪吃蛇 /蛇越长跑得越快/ /作者:SGAFPZ/ #include <stdio.h> #include <windows.h> #include <stdlib.h> #include <math.h> //#...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,207
精华内容 882
关键字:

贪吃蛇c语言

c语言 订阅