C语言实现贪吃蛇（三）----结构+链表实现

最新推荐文章于 2024-04-27 14:34:57 发布
最新推荐文章于 2024-04-27 14:34:57 发布
阅读量1w 收藏 69
点赞数 11
分类专栏： c 文章标签： c语言

前言：

本博客所讲到的知识跟前面我的两篇博客：《C语言实现贪吃蛇（一）—-数组实现》、《C语言实现贪吃蛇（二）—-局部刷新》 有很大的关系，建议大家前往看一下，尤其是第一篇，那篇博客是所有关于贪吃蛇游戏的基础。

之前的两篇博客将运用的C语言知识限定在了一般的数组上，但如果已经完整地了解过C语言的话，运用结构和链表会让程序的结构更明了，逻辑更清晰。这篇博客就将介绍如何用结构和链表改善之前的程序。

程序实现：

首先，把蛇看成一条单链表（还挺形象），蛇的每一节就是一个节点，以下是蛇节点的定义：

//蛇结点 
typedef struct node{
    //COORD是Windows API中定义的一种结构，表示一个字符在控制台屏幕上的坐标
    COORD cor;      //蛇节点坐标
    struct node * next;     //该节点的下一节点
} snake_node;

老套路，我们来看看程序修改后的一些变量和函数声明：

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>

//72,80,75,77是方向键对应的键值
#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
#define SNAKE 1
#define FOOD 2
#define BAR 3

//用链表实现 

//蛇结点 
typedef struct node{
    //COORD是Windows API中定义的一种结构，表示一个字符在控制台屏幕上的坐标
    COORD cor;
    struct node * next;
}snake_node;

//初始化食物坐标
COORD food = {3,5};

//初始化蛇头
snake_node * snake_head;

//蛇长
char len = 1; 

//坐标比较函数(程序中有多次的坐标比较)
int cor_cmp(COORD pt1,COORD pt2); 
//将光标移动到命令行的 （x，y）位置，参数是一个坐标结构体 
void gotoxy(COORD pt);
//初始化游戏
void init_game(void);
//生成食物坐标
COORD generate_food(void); 
//移动蛇 
void move_snake(int dir); 
//释放申请的内存空间 
void free_node(snake_node * n);
//获取方向函数（注意当蛇身长度超过一节时不能回头）
int get_dir(int old_dir);
//判断蛇死活的函数(判断了蛇是否撞到边界或者自食)
int isalive(void);

int main(void) {
    int dir = UP;   //初始方向默认向上，UP是我们定义的宏
    init_game();    //初始化游戏 
    while(1){
        dir = get_dir(dir);     //获取方向(我们摁下的方向)
        move_snake(dir);        //移动蛇身
        if(!isalive()){         //判断蛇的生命状态
            break;
        }
    }
    //清除屏幕 
    system("cls");
    printf("Game Over!\n");
    //释放申请的内存空间 
    free_node(snake_head); 

    return 0;
}

这篇博客是对 《C语言实现贪吃蛇（二）—-局部刷新》 进行的优化，在该优化中我们修改的方面有一下几点（由于坐标存储的方式发生改变，因此所有的函数都得改变）：

  1. 蛇节点使用结构体存储
  2. 坐标改用 COORD 结构体存储
  3. 增加坐标比较函数（因为坐标比较次数较多）
  4. 增加链表释放函数（蛇挂了之后，释放蛇单链表）
  5. 由于坐标存储的方式发生改变，因此所有的函数都得改变

我们先来看坐标比较函数，其实这个函数是很简单的：
也就对每个点的 x、y 坐标分别比较

//坐标比较函数(程序中有多次的坐标比较)
int cor_cmp(COORD pt1,COORD pt2); 

int cor_cmp(COORD pt1, COORD pt2)
{
    return (pt1.X == pt2.X && pt1.Y == pt2.Y);
}

//将光标移动到命令行的 （x，y）位置，参数是一个坐标结构体
void gotoxy(COORD pt);

void gotoxy(COORD pt)
{
    //句柄 
    HANDLE hout;

    //GetStdHandle函数获取一个指向特定标准设备的句柄，包括标准输入，标准输出和标准错误。
    //STD_OUTPUT_HANDLE正是代表标准输出（也就是显示屏）的宏 
    hout = GetStdHandle(STD_OUTPUT_HANDLE);

    //SetConsoleCursorPosition函数用于设置控制台光标的位置
    SetConsoleCursorPosition(hout, pt);
}

//初始化游戏
void init_game(void);

void init_game(void){
    //初始化蛇头 （3，9）
    snake_head = (snake_node *)malloc(sizeof(snake_node));    //从无到有，必须手动申请内存
    (snake_head->cor).X = 3;
    (snake_head->cor).Y = 9;
    snake_head->next= NULL;

    int i,j;    //i,j对应x,y轴  
    for(j = 0;j < 17;j ++){
        for (i = 0; i<17; i++) {
            //围墙
            if (i == 0 || i == 16 || j == 0 || j == 16)
            {
                putchar('#');
            }
            //蛇身
            else if (i == (snake_head->cor).X && j == (snake_head->cor).Y)
            {
                putchar('*');
            }
            //食物
            else if (i == food.X && j == food.Y)
            {
                putchar('$');
            }
            //空白地方
            else
            {
                putchar(' ');
            }
        }
        putchar('\n');
    }
}

//生成食物坐标
COORD generate_food(void); 

COORD generate_food(void){
    COORD food_;
    snake_node * p = NULL;      //把定义的指针初始为NULL是一个好习惯
    int in_snake = 0;
    //以当前时间为参数提供种子供rand()函数生成更为随机的数
    srand((unsigned int)time(NULL));
    //循环产生在边界内且不在蛇身上的食物
    do {
        food_.X = rand() % 16;
        food_.Y = rand() % 16;
        for (p = snake_head; p != NULL; p = p->next){
            //在蛇身上 
            if (cor_cmp(food_,p->cor)){
                in_snake = 1;       
            }
        }

    } while (food_.X == 0 || food_.X == 16 || food_.Y == 0 || food_.Y == 16 || in_snake);

    return food_;
}

好了，有了这些改进过的 函数，我们就可以写出move_snake函数了。这时我们还需要考虑的一个问题是我们该如何利用链表存储蛇的坐标。链表的一个优势在于它是动态的，它的单元数不像数组一样一开始就是被写死的。我们自然而然地想到当蛇吃到食物时，就向链表尾部追加一个单元。至于如何更新蛇的坐标，有两个办法，第一种是像之前数组的方法一样，从蛇头开始向后传递坐标，其代码如下：

//移动蛇
void move_snake(int dir); 

//像之前数组一样移动蛇
//通过将蛇头原来的坐标赋给第二节，原来的第二节赋给第三节，依次下去，完成蛇坐标的更新 
void move_snake(int dir)
{
    snake_node * p = NULL;
    COORD last = snake_head->cor, current;    //last与current用于之后蛇坐标的更新
    int grow = 0;

    switch (dir) {
        case UP:
            (snake_head->cor).Y--;
            break; 
        case DOWN:
            (snake_head->cor).Y++;
            break;
        case LEFT:
            (snake_head->cor).X--;
            break;
        case RIGHT:
            (snake_head->cor).X++;
            break;
    }

    //蛇吃到食物 
    if (cor_cmp(snake_head->cor,food)) {
        grow = 1;
        //生成新的食物 
        food = generate_food();
    }

    for (p = snake_head->next; p != NULL; p = p->next) {
        current = p->cor;
        p->cor = last;
        last = current;
    }

    gotoxy(snake_head->cor);
    putchar('*');     //打印新的蛇头

    if (grow) {
        //找到蛇尾 p
        p = snake_head;
        while(p->next != NULL){
            p = p->next;
        }

        p->next = (snake_node *)malloc(sizeof(snake_node));     //在蛇尾追加节点
        p->next->cor = last;
        p->next->next = NULL;

        len++;

        //打印新的食物 
        gotoxy(food);
        putchar('$');
    }else {
        //这是为了避免当你把蛇绕成一个圈的时候（蛇头紧跟蛇尾，没咬到），清除蛇尾顺便也把蛇头清除掉了 
        if(!cor_cmp(snake_head->cor,last)){
            gotoxy(last);
            putchar(' ');
        }
    }

    //避免光标一直跟着蛇尾（或食物 ）
    COORD foot = {0,17};    //将光标置于左下角 
    gotoxy(foot);

    Sleep(500);
}

另一种更新坐标的方法是每次移动时申请一块新的内存空间存储移动后的蛇头坐标并让 snake_head 指针指向它，如果蛇不长节的话就释放蛇尾的内存空间，通俗来说就是添头去尾，这样就避免了蛇中间节点的移动过程（原来的蛇头自然而然成为第二节，原来第二节也成了第三节，而他们的坐标都没发生变化） 。

void move_snake(int dir)
{
    snake_node * p,* t = NULL;
    snake_node * newh = NULL;    //新的蛇头
    newh = (snake_node *)malloc(sizeof(snake_node));    //为新蛇头开辟内存空间
    newh->cor = snake_head->cor;    //把旧头的坐标赋给新头
    newh->next = snake_head;        //把新头的next指针指向旧头
    snake_head = newh;              //让头指针指向新开辟的内存空间

    int grow = 0;

    switch (dir) {
        case UP:
            (snake_head->cor).Y--;
            break; 
        case DOWN:
            (snake_head->cor).Y++;
            break;
        case LEFT:
            (snake_head->cor).X--;
            break;
        case RIGHT:
            (snake_head->cor).X++;
            break;
    }
    //蛇吃到了食物 
    if (cor_cmp(snake_head->cor,food)) {
        grow = 1;
        //生成新的食物 
        food = generate_food();
    }

    gotoxy(snake_head->cor);
    putchar('*');

    //如果长节的话不再对链表进行操作
    if (grow) {
        len ++;
        gotoxy(food);
        putchar('$');
    }
    //不长节的话就得删除蛇尾
    else {
        //找到倒数第二节
        p = snake_head;
        while(p->next->next != NULL){
            p = p->next;
        } 
        //记录下最后一节的地址
        t = p->next;
        //将倒数第二节的next指针赋值为NULL
        p->next = NULL;

        //这是为了避免当你把蛇绕成一个圈的时候（蛇头紧跟蛇尾，没咬到），清除蛇尾顺便也把蛇头清除掉了 
        if(!cor_cmp(snake_head->cor,t->cor)){
            gotoxy(t->cor);
            putchar(' ');
        }

        free(t);        //释放蛇尾的内存空间
    }

    //避免光标一直跟着蛇尾（或食物 ）
    COORD foot = {0,17};    //将光标置于左下角 
    gotoxy(foot);

    Sleep(500);
}

在游戏结束之后，我们还得手动释放构造链表而申请的内存空间：

//释放申请的内存空间
void free_node(snake_node * n);

void free_node(snake_node * h){
    snake_node * p = h,* q;
    while(p != NULL){
        q = p;
        p = p->next;
        free(q);    
    }
}

最后判断该蛇挂没挂：

//判断蛇死活的函数(判断了蛇是否撞到边界或者自食)
int isalive(void);

int isalive(void){
    int self_eat = 0;
    snake_node * p = NULL;
    for (p = snake_head->next; p != NULL; p = p->next)
    {
        if (cor_cmp(p->cor, snake_head->cor))
        {
            self_eat = 1; 
        } 
    }

    return ((snake_head->cor).X == 0 || (snake_head->cor).X == 16 || (snake_head->cor).Y == 0 || (snake_head)->cor.Y >= 16 || self_eat) ? 0 : 1;
}

根据以上的改进，我们顺利的利用 结构+链表 实现了贪吃蛇的小游戏，对前面的代码实现了优化。

没错！这篇博客还是参考自前面两篇博客的原作者的 《C语言实现贪吃蛇之结构链表篇 》。

这已经是第三篇参考（Copy）该作者的博客了，按理说也差不多了，再这样下去我都感觉自己有点小无耻了。。。

但毕竟是我感觉而已，本着坚持就是胜利的求知精神，我决定将无耻进行到底。在后续的博客中，我将跟随着原作者的脚步继续折腾这个游戏，感兴趣的同学可以看看后续的文章。

LSGOZJ
关注
  • 11
    点赞
  • 踩
  • 69
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言七彩贪吃蛇源代码---AI自动寻径，分数排行，数据保存，背景音乐难度设置等 控制台小游戏
qq_16620025的博客
07-24 3311
------------------------------------------------------------------------------------------- 七彩贪吃蛇小游戏V1.0 使用纯C语言编写的控制台贪吃蛇小游戏，可设置游戏难度，有连击分数加成，蛇身颜色自动随机变化，缓冲防闪，数据存储保护，排行榜与音效等功能,VC++与VS编译均通过，只使用V...
C语言实现链表贪吃蛇
08-19
链表贪吃蛇游戏的设计和实现是基于C语言实现链表数据结构的游戏设计。游戏的主要模块包括移动光标模块、打印地图模块、产生食物模块、蛇的生命状态判断模块、运行模块和结束模块。游戏的实现使用了C语言和Windows ...
C语言 贪吃蛇游戏
dark_cy的博客
05-28 1万+
　　实现了贪吃蛇游戏的基本功能，并实现每次得分的记录及排行。 效果如下图 主页 游戏页面 失败页面 排行榜 直接上代码 代码中有基本的注释 #include<windows.h> #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<math.h&g...
使用C语言实现贪吃蛇小游戏（双向链表实现）
CX19970的博客
03-27 1071
使用纯C实现贪吃蛇小游戏，欢迎小伙伴探讨使用纯C实现的其他算法。感兴趣的伙伴可以自己也试着写一下，如果纯C不太容易，使用其他面向对象的语言实现会轻松不少。可使用上/下/左/右键或A/S/D/W键控制贪吃蛇移动方向。
C语言:贪吃蛇
最新发布
2302_81053095的博客
04-27 1330
​ 贪吃蛇，一种很贪吃的蛇。 贪吃蛇是一款久负盛名的游戏，它也和俄罗斯方块，扫雷等游戏位列经典游戏的行列。 接下来，我们用500行代码实现这个游戏！ ​
贪吃蛇c++
Tudou_Pika的博客
03-26 737
endx和endy存蛇尾坐标。tim是每次刷新蛇身的毫秒数。v数组是地图 v中1代表蛇身，2代表食物。n，m都是存蛇身坐标。这两个函数是上网抄的，go是把光标移动到x，y这个位置。cv是更改输出的字体及背景颜色。这段不难理解，v中1是蛇身，用food函数随机生出食物坐标。先写一个无限循环，用来每次打印蛇身。蓦然回首，那蛇却在灯火阑珊处。代码很容易理解，循环与函数。接下来把各个代码块合起来。一些有关游戏功能的函数。眉间盈盈，码量如蚁。...
C语言实现贪吃蛇（详细版）
热门推荐
m0_73906588的博客
05-12 3万+
以上就是贪吃蛇的基本内容啦，完结撒花~下面有一些想说的话：这篇文章的完成时间是2023.5.12，我现在是一名大一下的计科学生，其实C语言在去年十月份的中旬就看完了翁恺老师的网课，那个时候其实就有能力完成这个贪吃蛇的编写了，但是知道现在才写完，其实是走了很多弯路，耽误了不少时间北哥，在加入北哥的知识星球”编程指北“后才回正了自己的学习方向，也希望大家都能在正确的道路上越走越远~
C语言实现贪吃蛇[内附详细步骤]
如是牛
09-12 2万+
C语言实现一款经典的贪吃蛇小游戏
c语言贪吃蛇
qq_74222589的博客
11-20 1752
c语言贪吃蛇
用C语言写贪吃蛇
c3872931的博客
07-16 3174
在黑色窗口，输入方向键。需要的C语言图形库以在。
链表-使用C语言单链表实现的贪吃蛇小游戏.zip
03-13
链表 链表_使用C语言单链表实现的贪吃蛇小游戏
数据结构课程设计贪吃蛇
06-22
这个一个数据结构的课程设计，内容是贪吃蛇游戏，运行环境是wintc
简单贪吃蛇代码(链表)
02-18
用C++写的一个简单的贪吃蛇游戏代码，是链表实现。简单的实现了无限添加结点，随机出现食物位置和蛇头出界退出游戏。
C语言220个经典源码包括10多个实例开发（数据结构算法）
10-21
包括了220个C语言源代码，C语言数据结构中的内容，算法。后面附10多个实例开发
C语言链表实现贪吃蛇游戏
08-29
主要介绍了C语言链表实现贪吃蛇游戏源码，适合C语言入门者学习阅读，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现贪吃蛇
qq_49723651的博客
05-13 1万+
C语言实现贪吃蛇 贪吃蛇项目是在b站的一位老师那里边学边敲的（现在视频被老师删掉了），在这里记录一下代码和学习时的一些思考，希望自己以后能用链表将贪吃蛇实现。 思考过程： 贪吃蛇 C语言实现 1.打印首页 --FirstPage() 功能：提示用户按下空格开始游戏。; 知识点：C语言中接受直接接受键盘的一个字符而不用按回车就开始执行下一步命令的函数：_getch()，在conio.ht头文件中。 2.清空屏幕 --TestSpace() 功能：用户按下空格以后清空首页。 知识点：利用system("
C语言小项目——基于链表的贪吃蛇
qq_54378635的博客
08-16 2166
贪吃蛇
C语言新手入门贪吃蛇的链表实现-控制光标位置，流畅不闪屏
闪耀大叔的博客
07-26 2171
一个简单的控制台小游戏，用链表实现贪吃蛇。 很多同学刚学C语言，不知道能干嘛。其实C语言什么都能干，只不过可能比较复杂，但深入学习C语言，对于底层数据结构和算法原理学习极有好处。 以后再学习其他语言，学习速度跟坐飞机一样。 比如这个贪吃蛇小程序，如果能写出来，说明对于指针和链表的理解就比较透彻了。下面一步步讲解。...............
C语言实现贪吃蛇，链表实现，图文详解，含登陆系统
weixin_62244902的博客
04-04 1万+
C语言实现贪吃蛇，链表实现，图文详细讲解，看完必会，涵盖了链表的头插法新结点生成、遍历链表、链表的动态内存分配，且有完整的登录注册账号密码的界面，完整的菜单界面，最高分记录，用户信息储存，菜单跳转等等
c语言随机生成字母链表,C语言实现链表贪吃蛇
06-07
生成字母链表可以使用C语言的随机数生成函数rand()，然后将生成的数字转换成字母即可。以下是生成长度为n的字母链表的示例代码： ``` #include <stdio.h> #include <stdlib.h> #include <time.h> typedef struct Node { char data; struct Node *next; } Node; Node *createList(int n) { Node *head = NULL; Node *tail = NULL; srand(time(NULL)); for (int i = 0; i < n; i++) { Node *node = (Node *) malloc(sizeof(Node)); node->data = rand() % 26 + 'a'; node->next = NULL; if (head == NULL) { head = node; tail = node; } else { tail->next = node; tail = node; } } return head; } void printList(Node *head) { while (head != NULL) { printf("%c ", head->data); head = head->next; } printf("\n"); } int main() { Node *list = createList(10); printList(list); return 0; } ``` 接下来是实现链表贪吃蛇的示例代码。链表贪吃蛇可以通过一个链表来表示蛇的身体，每个节点表示一个身体部位，头节点表示蛇头，尾节点表示蛇尾。蛇的运动可以通过在链表头部添加一个节点来实现。以下是示例代码： ``` #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <windows.h> #define WIDTH 30 #define HEIGHT 20 typedef struct Point { int x; int y; } Point; typedef struct Node { Point data; struct Node *next; } Node; typedef enum Direction { UP, DOWN, LEFT, RIGHT } Direction; Node *createSnake(Point head) { Node *node = (Node *) malloc(sizeof(Node)); node->data = head; node->next = NULL; return node; } void printSnake(Node *snake) { while (snake != NULL) { printf("(%d,%d) ", snake->data.x, snake->data.y); snake = snake->next; } printf("\n"); } void drawMap(Node *snake, Point food) { system("cls"); for (int i = 0; i < HEIGHT; i++) { for (int j = 0; j < WIDTH; j++) { if (i == 0 || i == HEIGHT - 1 || j == 0 || j == WIDTH - 1) { printf("#"); } else if (i == food.y && j == food.x) { printf("$"); } else { int found = 0; Node *p = snake; while (p != NULL) { if (p->data.x == j && p->data.y == i) { printf("*"); found = 1; break; } p = p->next; } if (!found) { printf(" "); } } } printf("\n"); } } int isCollided(Node *snake) { Node *p = snake->next; while (p != NULL) { if (p->data.x == snake->data.x && p->data.y == snake->data.y) { return 1; } p = p->next; } return 0; } int isInMap(Point point) { return point.x > 0 && point.x < WIDTH - 1 && point.y > 0 && point.y < HEIGHT - 1; } Point generateFood(Node *snake) { Point food; do { food.x = rand() % (WIDTH - 2) + 1; food.y = rand() % (HEIGHT - 2) + 1; } while (!isInMap(food) || isCollided(snake)); return food; } void moveSnake(Node **snake, Direction direction, Point food, int *score) { Point head = (*snake)->data; switch (direction) { case UP: head.y--; break; case DOWN: head.y++; break; case LEFT: head.x--; break; case RIGHT: head.x++; break; } Node *node = (Node *) malloc(sizeof(Node)); node->data = head; node->next = *snake; *snake = node; if (head.x == food.x && head.y == food.y) { food = generateFood(*snake); *score += 10; } else { Node *tail = *snake; while (tail->next->next != NULL) { tail = tail->next; } free(tail->next); tail->next = NULL; } drawMap(*snake, food); } int main() { srand(time(NULL)); Point head = {WIDTH / 2, HEIGHT / 2}; Node *snake = createSnake(head); Direction direction = RIGHT; Point food = generateFood(snake); int score = 0; while (1) { if (_kbhit()) { char ch = _getch(); if (ch == 'w' && direction != DOWN) { direction = UP; } else if (ch == 's' && direction != UP) { direction = DOWN; } else if (ch == 'a' && direction != RIGHT) { direction = LEFT; } else if (ch == 'd' && direction != LEFT) { direction = RIGHT; } } moveSnake(&snake, direction, food, &score); if (!isInMap(snake->data) || isCollided(snake)) { printf("Game Over! Score: %d\n", score); break; } Sleep(100); } return 0; } ``` 代码中使用了Windows系统的控制台函数和键盘输入函数，需要在Windows系统下运行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值