字符游戏-智能蛇

最新推荐文章于 2024-06-22 14:25:15 发布
原创 最新推荐文章于 2024-06-22 14:25:15 发布 · 688 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#人工智能 #贪吃蛇 #BFS

之前看到下面这样一幅gif动图的时候，都会忍不住花上个几分钟把它看完，看看这条蛇如何骚操作跑完全图
AI蛇
看别人跑还不够过瘾，所以得自己来写代码让自己的智能蛇也来跑一跑，看看是否也能够做到这么智能，跑完全图。

于是，在多次观察这条蛇的路径以及上网查阅一些资料之后，得到以下的初步分析：
1. 蛇的身体以及地图的边界是不可接触的格子，相当于障碍物；
2. 因为贪吃蛇移动是一个动态的过程，所以每走一步，要重新进行寻路；
3. 吃完食物蛇的长度变长，蛇尾巴位置不变，因此食物跟尾巴之间要留有空隙；
4. 如果一直跟着尾巴走，就永远不会没有路；
5. 随机出现的食物位置可能会堵住蛇头部到尾巴的路径，使得头部没有办法找到尾巴，但只要食物与尾巴之间有空隙，吃掉食物是安全的，而且可以重新找到从头部到尾巴的路径。

然后，慢慢摸索出实现智能蛇的算法：
1 获取当前地图智能蛇头部(head)的位置(snakex[len], snakey[len])、尾部(tail)的位置(snakex[1], snakey[1])，以及食物(food)的位置(foodx, foody)；
2 对head to food、head to tail、food to tail各自进行一次BFS搜索，并将搜索结果存到step_h2f、step_h2t和step_f2t 数组中

int step_h2f[MAP_SIZE][MAP_SIZE]; // head to food
int step_h2t[MAP_SIZE][MAP_SIZE]; // head to tail
int step_f2t[MAP_SIZE][MAP_SIZE]; // food to tail
bfs(foodx, foody, snakex[len], snakey[len], step_h2f);
bfs(snakex[1], snakey[1], snakex[len], snakey[len], step_h2t);
bfs(snakex[1], snakey[1], foodx, foody, step_f2t);

3 判断是否能够找到从头部到尾巴路径A
1) 若找到路径A，寻找从头部到食物的路径B，
a. 如果找到，则向着食物的方向跟着尾巴走一步；
b. 如果不能找到路径B，就先跟着尾巴后面绕几步，直到出现安全路径B；
2) 若找不到路径A，则先吃食物，再继续跟尾巴走；

#define inf 999
...
if (step_h2t[snakex[len]][snakey[len]] < inf){
    // 寻找安全的吃食物的路径
    int x, y, minb = 4, t = 4;
    int i = fdir;
    int b[5] = { inf, inf, inf, inf, inf }; // min
    int c[4] = { 0, 0, 0, 0 };
    while (t--){
        while (c[i]) i = rand() % 4; 
        c[i] = 1;
        x = snakex[len] + dx[i];
        y = snakey[len] + dy[i];
        if (is_space(x, y) && step_h2t[x][y] < inf)
            b[i] = step_h2f[x][y];
        if (is_food(x, y) && step_f2t[x][y] < inf && step_f2t[x][y] > 1)
            b[i] = 0;
        if (b[i] < b[minb]) minb = i;
    }
    if (b[minb] == inf)
        return find_farthest_way(); // 找不到安全的吃食物路径，先跟尾巴走一步
    else
        return fdir = minb % 4; // 已找到最短安全路径，返回方向
}
else return get_food(); // 从头部到尾巴的路被食物堵住时，先吃食物

这样基本就完成了智能蛇的大致算法，补充完find_farthest_way()和get_food()两个函数就能跑起来了，总的来说，算法还算是比较满意，全图最大长度100，一般都能够跑到90+的长度，运气好一点的情况则可以跑完全图
AI_snake
最终效果如图（跑完全图），由于录制设备的问题，颜色显示不出来，设置连头部也跟背景颜色融为一体了….
AI_snake
其实目前仍然存在的一个最大问题就是在智能蛇去吃食物的时候，难以避免出现一些单独的洞，而且有时很难去修复它，所有到后期这些洞很可能就成为智能蛇的葬身之处。所以，后来修改为，到了后期（长度超过一半时）就强行搜索最远的路径，无论是否能找到安全到达食物的路径，以尽可能减少空洞。

源代码：

#include <stdlib.h>
#include <time.h>
#include <Windows.h>

#define SNAKE_MAX_LENGTH 100
#define SNAKE_HEAD 'O'
#define SNAKE_BODY 'o'
#define SNAKE_FOOD '$'
#define SNAKE_TAIL '*'
#define MAP_SIZE 12
#define inf 999

void print();
void HideCursor();
void put_food();
int snake_move(int);
int is_over(int, int);
int is_food(int, int);
int is_space(int, int);
int get_direction();
int find_farthest_way();
int get_food();
void bfs(int, int, int, int, int *(*)[MAP_SIZE]);
void initial();

int foodx, foody, fdir = 1, len = 5;
int dx[] = { -1, 0, 1, 0 }; // up, down, left, right
int dy[] = { 0, 1, 0, -1 };
int snakex[SNAKE_MAX_LENGTH] = { 0, 1, 1, 1, 1, 1 };
int snakey[SNAKE_MAX_LENGTH] = { 0, 1, 2, 3, 4, 5 };

struct note{
    int x;
    int y;
    int f;
    int s;
};

int step_h2f[MAP_SIZE][MAP_SIZE]; // head to food
int step_h2t[MAP_SIZE][MAP_SIZE]; // head to tail
int step_f2t[MAP_SIZE][MAP_SIZE]; // food to tail
char map[MAP_SIZE][MAP_SIZE] = {
    " __________ ",
    "|ooooO     |",
    "|          |",
    "|          |",
    "|          |",
    "|          |",
    "|          |",
    "|          |",
    "|          |",
    "|          |",
    "|          |",
    " ~~~~~~~~~~ "
};

void main()
{
    srand((unsigned int)time(NULL));
    HideCursor();
    while (1){
        initial();
        // start
        while (!snake_move(get_direction()));
        // end
        if (len == 100) printf("Win!\n");
        else printf("Game over!\nThe length of the snake is %d\n", len);
        printf("Enter \'q\' to quit or any other keys to restart.\n");
        char c = getchar();
        if (c == 'q') break;
    }
    return;
}
void initial(){
    fdir = 1, len = 5;
    int i, j;
    for (i = 1; i <= len; i++){
        snakex[i] = 1;
        snakey[i] = i;
        map[1][i] = SNAKE_BODY;
    }
    for (i = len + 1; i <= MAP_SIZE - 2; i++) map[1][i] = ' ';
    for (i = 2; i < MAP_SIZE - 1; i++)
        for (j = 1; j < MAP_SIZE - 1; j++)
            map[i][j] = ' ';
    put_food();
    print();
}
void color(const unsigned short color1)
{
    if (color1 >= 0 && color1 <= 15)
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color1);
    else
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}
void HideCursor()
{
    CONSOLE_CURSOR_INFO cursor_info = { 1, 0 };
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}
void print(){
    system("cls");
    for (int i = 0; i < MAP_SIZE; i++){
        for (int j = 0; j < MAP_SIZE; j++){
            if (is_food(i, j)){
                color(14); printf("%c", map[i][j]); color(15);
            }
            else if (i == 0 || i == 11 || j == 0 || j == 11){
                color(11); printf("%c", map[i][j]); color(15);
            }
            else if (map[i][j] == SNAKE_HEAD){
                color(11); printf("%c", SNAKE_HEAD); color(15);
            }
            else if (i == snakex[1] && j == snakey[1]){
                color(11); printf("%c", SNAKE_TAIL); color(15);
            }
            else printf("%c", map[i][j]);
        }
        printf("\n");
    }
}
void put_food(){
    int x, y;
    while (map[x = rand() % 10 + 1][y = rand() % 10 + 1] != ' ');
    map[x][y] = SNAKE_FOOD;
    foodx = x;
    foody = y;
}
int snake_move(int dir){
    int x = snakex[len] + dx[dir];
    int y = snakey[len] + dy[dir];
    // grow
    if (map[x][y] == SNAKE_FOOD){
        map[snakex[len]][snakey[len]] = SNAKE_BODY;
        len++;
        snakex[len] = x;
        snakey[len] = y;
        map[x][y] = SNAKE_HEAD;
        put_food();
        print();
        return 0;
    }
    // game over
    if (map[x][y] != ' ') return 1;
    // move
    map[snakex[1]][snakey[1]] = ' ';
    for (int i = 1; i < len; i++){
        snakex[i] = snakex[i + 1];
        snakey[i] = snakey[i + 1];
    }
    map[snakex[len - 1]][snakey[len - 1]] = SNAKE_BODY;
    snakex[len] += dx[dir];
    snakey[len] += dy[dir];
    map[snakex[len]][snakey[len]] = SNAKE_HEAD;
    print();
    return 0;
}
int is_over(int x, int y){
    int i, over = 0;
    char c;
    for (i = 0; i < 4; i++){
        c = map[x + dx[i]][y + dy[i]];
        if (c != ' ' && c != SNAKE_FOOD) over++;
    }
    return over;
}
int is_food(int x, int y){
    return (x == foodx && y == foody);
}
int is_space(int x, int y){
    return map[x][y] == ' ';
}
int get_direction(){
    if (!is_over(snakex[len], snakey[len])) return 1;
    bfs(foodx, foody, snakex[len], snakey[len], step_h2f);
    bfs(snakex[1], snakey[1], snakex[len], snakey[len], step_h2t);
    bfs(snakex[1], snakey[1], foodx, foody, step_f2t);
    if (step_h2t[snakex[len]][snakey[len]] == inf) return get_food(); // 找不到尾巴找食物
    else{
        if (len > 50) return find_farthest_way(); // 长度大于50采取保守跑法
        int x, y, minb = 4, t = 4;
        int i = fdir;
        int b[5] = { inf, inf, inf, inf, inf }; // min
        int c[4] = { 0, 0, 0, 0 };
        while (t--){
            while (c[i]){ i = rand() % 4; }
            c[i] = 1;
            x = snakex[len] + dx[i];
            y = snakey[len] + dy[i];
            if (is_space(x, y) && step_h2t[x][y] < inf) b[i] = step_h2f[x][y];
            if (is_food(x, y) && step_f2t[x][y] < inf && step_f2t[x][y] > 1) b[i] = 0;
            if (b[i] < b[minb]) minb = i;
        }
        if (b[minb] == inf) return find_farthest_way(); // 找不到安全的吃食物路径，先跟尾巴
        else return fdir = minb % 4; // 已找到最短安全路径
    }
}
int find_farthest_way(){
    int i = fdir;
    int x, y, maxb = 4, t = 4;
    int d[5] = { -1, -1, -1, -1, -1 };
    while (t--){
        x = snakex[len] + dx[i];
        y = snakey[len] + dy[i];
        if (is_space(x, y)) d[i] = step_h2t[x][y];
        if (is_food(x, y) && step_f2t[x][y] < inf && step_f2t[x][y] > 1) d[i] = step_f2t[x][y];
        if ((is_food(x, y) || step_h2f[x][y] < inf) && step_f2t[x][y] < inf) d[i] = step_f2t[x][y];
        if (d[i] > d[maxb] && d[i] < inf) maxb = i;
        i = (i + 1) % 4;
    }
    return fdir = maxb % 4;
}
int get_food(){
    int i = fdir;
    int x, y, maxb = 4, t = 4;
    int d[5] = { -1, -1, -1, -1, -1 };
    while (t--){
        x = snakex[len] + dx[i];
        y = snakey[len] + dy[i];
        if (is_food(x, y) && len == 99) return i;
        if (is_space(x, y) || (is_food(x, y) && step_f2t[x][y] > 1)) d[i] = step_h2f[x][y];
        if (d[i] > d[maxb] && d[i] < inf) maxb = i;
        i = (i + 1) % 4;
    }
    return fdir = maxb % 4;
}
void bfs(int x, int y, int tx, int ty, int *(*step)[MAP_SIZE]){
    struct note que[102];
    int xx, yy, head, tail;
    int book[MAP_SIZE][MAP_SIZE] = { 0 };
    for (int i = 0; i < MAP_SIZE; i++)
        for (int j = 0; j < MAP_SIZE; j++)
            *(*(step + i) + j) = inf;
    *(*(step + x) + y) = 0;
    book[x][y] = 1;
    head = 1; tail = 1;
    que[tail].x = x;
    que[tail].y = y;
    que[tail].f = 0;
    que[tail].s = 0;
    tail++;
    int done = 0;
    while (head < tail){
        for (int k = 0; k < 4; k++){
            xx = que[head].x + dx[k];
            yy = que[head].y + dy[k];
            if (xx == 0 || xx == 11 || yy == 0 || yy == 11) continue;
            if (book[xx][yy] == 0 && is_space(xx, yy)){
                book[xx][yy] = 1;
                que[tail].x = xx;
                que[tail].y = yy;
                que[tail].f = head;
                que[tail].s = que[head].s + 1;
                *(*(step + xx) + yy) = que[tail].s;
                tail++;
            }
            if (xx == tx && yy == ty) done++;
            if (done == 4) return;
        }
        if (done == 4) return;
        head++;
    }
    int i = 4;
    while (i--){
        xx = tx + dx[i];
        yy = ty + dy[i];
        if (*(*(step + xx) + yy) < *(*(step + tx) + ty) - 1) *(*(step + tx) + ty) = *(*(step + xx) + yy) + 1;
    }
}
字符游戏-贪吃蛇之寻路算法探索
weixin_39637396的博客
12-28 938
2013年，某gif图在百度贴吧和微博引起了疯传。 好吧，就是下面这张。。观察这个gif，你会发现这个智能蛇，真的很智能，不像我们写的蛇那么地智障。。我这篇博文，就是来介绍如何才能写出不那么智障的贪吃蛇。经过这几天的学习，通过学习网上的资料和同学的博客代码（我终于知道了一个事实，大神就在身边），真的学到了很多东西，在我的初略划分下，智能贪吃蛇大致可以分为三个流派。 BFS派 A*派 Hamiton
【Linux】字符游戏-智能蛇
yuxy36的博客
12-26 300
这周作业——智能蛇。 其目的是让蛇自动一秒走一步，自动寻找食物。 实现这个目的的难点有以下几个： 让系统每秒printf一次。 让智能蛇自动寻找食物 linux下的指令运用 1.让系统每秒输出一次。 对策：使用sleep函数 具体使用方法及注意事项： - 在头文件加入 unistd.h 头文件 - 注意sleep的开头是小写（区别于windows）
字符游戏-智能蛇（代码版）
yaody7的博客
12-23 1081
这篇文章主要是上一篇文章的实际操作部分。下面是伪代码int main (void) { initialization（）； //初始化生成蛇和地图，还有金币 judge（）； //判断蛇头四周的情况，障碍在哪。通过全局变量返回结果。 if （周围有金币） eatcoin（）；
字符游戏-智能蛇（下）
yuxy36的博客
12-21 823
字符游戏-智能蛇（下） 上周的作业是写出字符游戏-贪吃蛇的小程序。在完成这个项目之后，我将理清思路，记录一下我的学习过程。 让蛇动起来 放置奖励的食物 在蛇吃到食物时延长蛇的身体 设置游戏结束的机制 在蛇吃到食物时延长蛇的身体 如何实现这一步呢？我的基本思路是：当蛇头接收的指令是向食物挪动一步并即将要覆盖食物时，蛇的身体先是会完成挪动的动作，随后再接收一次指令，蛇头挪
Python小游戏-贪吃蛇
最新发布
weixin_64054026的博客
06-22 1058
贪吃蛇游戏是一款经典的休闲益智游戏，玩家通过控制蛇的移动方向来吃掉屏幕上的食物，随着吃掉的食物数量增加，蛇的长度也会不断增长，游戏难度逐渐增加。
tanchishe.rar_游戏_贪吃蛇
09-21
其简单的操作方式和无尽的游戏模式使得它在各种平台都有广泛的应用，包括早期的诺基亚手机到现在的智能手机。本文将深入探讨"tanchishe.rar"这个压缩包中的游戏实现，主要关注"Text1.c"源代码文件，以及可能的辅助...
ai-snake-js：我的第一个javascript项目。 使用javascript进行人工智能蛇回购的相当粗略的重新共享
02-12
《使用JavaScript实现人工智能蛇游戏详解》 在编程领域，JavaScript是一种广泛应用的脚本语言，尤其在Web开发中占据着核心地位。"ai-snake-js"项目是初学者使用JavaScript进行AI（人工智能）应用的一个入门实践，它...
智能蛇算法
chenzhx_的博客
12-27 615
编写智能算法 编写人工智能程序，使得 snake 每秒自动走一步。
智能贪吃蛇c语言实现
Passenger317_的博客
12-27 1010
#include <stdio.h> #include <windows.h> #include <stdlib.h> #include <math.h> #include <conio.h> #include <string.h> #include <time.h> void food(); void show(); void move(); void turn(); void check();
智能蛇
LSUNQQ的博客
12-25 408
智能蛇
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值