Linux c 贪吃蛇 无curses、多线程、信号的实现

最新推荐文章于 2022-07-19 00:11:31 发布
最新推荐文章于 2022-07-19 00:11:31 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： C 文章标签： 终端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lc_Xs/article/details/69577472
版权 
这一版贪吃蛇功能还不完全，我将继续更新，十分希望各位大神帮助完善
/************************************
终端控制和键盘输入部分
keyboard.h
************************************/
#ifndef __KEYBOARD_H_
#define __KEYBOARD_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

//非阻塞无回显输入
int readch(void);  
//光标移动至指定位置
void gotoxy(int x,int y);   
//移动至指定位置并输出字符
void gotoxy_putc(int x,int y,char c);   
//移动至指定位置并输出字符串
void gotoxy_puts(int x,int y,char* c);
//初始化键盘输入和终端
void initkey();
//恢复键盘输入和终端属性
void relaykey();
//清屏
void clrter();

void clrter()
{
    system("clear");
}
int readch(void) 
{ 
        struct termios tm, tm_old; 
        int fd = STDIN_FILENO, c=0; 
      fd_set rfds;
        struct timeval tv;
        int retval;

        if(tcgetattr(fd, &tm) < 0) 
                return -1; 

        tm_old = tm; 

        cfmakeraw(&tm);

        FD_ZERO(&rfds);
        FD_SET(0, &rfds);

        tv.tv_sec  = 0;
        tv.tv_usec = 10;

        if(tcsetattr(fd, TCSANOW, &tm) < 0) 
                c = 0; 
      retval = select(1, &rfds, NULL, NULL, &tv);

        if (retval == -1) {
                c = 0;
        } else if (retval)  
            c = fgetc(stdin); 

        if(tcsetattr(fd, TCSANOW, &tm_old) < 0) 
                c = 0; 

        return c; 
}
void gotoxy(int x,int y)
{
    printf("\033[%d;%df\n",y,x);
}
void gotoxy_putc(int x,int y,char c)
{
    printf("\033[0m");
    printf("\033[%d;%df%c\n",y,x,c);
    printf("\033[8m");
}
void gotoxy_puts(int x,int y,char* c)
{
    printf("\033[0m");
    printf("\033[%d;%df%s\n",y,x,c);
    printf("\033[8m");
}
void initkey()
{
    clrter();
    system("stty -echo");
    printf("\033[8m");
    printf("\033[?25l");    
}
void relaykey()
{
    printf("\033[0m");
    system("stty echo");
    printf("\033[?25h");
}
#endif
/************************************
双向循环链表的实现（套用Linux内核）
List.h
************************************/
#ifndef __QUEUE_H__
#define __QUEUE_H__
/////////////////////////////////////////////////////////////////////////////////////////////////
//
//                                          队    列
//
/////////////////////////////////////////////////////////////////////////////////////////////////
#if defined(_WIN32) || defined(_WIN64)      //Windows
#define NETLIST_EXPORT  __declspec(dllexport)
#else
#define NETLIST_EXPORT 
#endif  //defined(_WIN32) || defined(_WIN64)
#ifndef LIST_HEAD_DEF

    #define LIST_HEAD_DEF
    typedef struct LIST_HEAD
    {
        struct LIST_HEAD *Next;
        struct LIST_HEAD *Prev;
    } LIST_HEAD;

#endif /*LIST_HEAD_DEF*/

    #define INIT_LIST_HEAD(ptr) do { \
        (ptr)->Next = ptr; (ptr)->Prev = ptr; \
    } while (0)

    #define EMPTY_LIST_HEAD(ptr) do { \
        (ptr)->Next = 0; (ptr)->Prev = 0; \
    } while (0)


#ifdef WIN32
    #define offset_of(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
    #define container_of(ptr, type, member) (type *)((char *)ptr - offset_of(type, member))
#else
    #ifdef __compiler_offsetof
        #define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
    #else
        #define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
    #endif

    #define container_of(ptr, type, member)                         \
    (                                                               \
        {                                                           \
            typeof( ((type *)0)->member ) *__mptr = (ptr);  \
            (type *)( (char *)__mptr - offsetof(type,member) );     \
        }                                                           \
    )
#endif

#define list_entry(ptr, type, member)   container_of(ptr, type, member)

#define ListForEachEntry(type,pos, head, member)                \
    for (pos = list_entry((head)->Next, type, member);          \
         pos->member.Next, &(pos->member) != (head);                \
         pos = list_entry(pos->member.Next, type, member)    \
         )

#define ListForEachEntrySafe(type,pos, n, head, member)         \
    for (pos = list_entry((head)->Next, type, member),          \
         n = list_entry(pos->member.Next, type, member);        \
         &pos->member != (head);                                \
         pos = n, n = list_entry(n->member.Next, type, member))

NETLIST_EXPORT void ListAddHead(LIST_HEAD *New, LIST_HEAD *Head);
NETLIST_EXPORT void ListInsert(LIST_HEAD *New, LIST_HEAD *Pos);
NETLIST_EXPORT void ListAddTail(LIST_HEAD *New, LIST_HEAD *Head);
NETLIST_EXPORT void ListDel(LIST_HEAD *entry);
NETLIST_EXPORT int  ListIsEmpty(const LIST_HEAD *Head);
#endif /* __QUEUE_H__ */

static void ListAdd(LIST_HEAD *New,LIST_HEAD *Prev,LIST_HEAD *Next)
{
    Next->Prev = New;
    New->Next =  Next;
    New->Prev =  Prev;
    Prev->Next = New;
}

void ListAddHead(LIST_HEAD *New, LIST_HEAD *Head)
{
    ListAdd(New, (LIST_HEAD *)Head->Next, Head);
}

void ListAddTail(LIST_HEAD *New, LIST_HEAD *Head)
{
    ListAdd(New, (LIST_HEAD *)Head->Prev, Head);
}

void ListInsert(LIST_HEAD *New, LIST_HEAD *Pos)
{
    Pos->Prev->Next = New;
    New->Next = Pos;
    New->Prev = Pos->Prev;
    Pos->Prev = New;
}

static void __ListDel(LIST_HEAD * Prev, LIST_HEAD * Next)
{
    Next->Prev = Prev;
    Prev->Next = Next;
}

void ListDel(LIST_HEAD *entry)
{
    if (entry->Prev)
    {
        __ListDel((LIST_HEAD *)entry->Prev, (LIST_HEAD *)entry->Next);
        entry->Prev = 0;
        entry->Next = 0;
    }
}

int ListIsEmpty(const LIST_HEAD *Head)
{
    return (LIST_HEAD *)Head->Next == Head;
}

/************************************
贪吃蛇的实现
************************************/

#include "keyboard.h"
#include "List.h"

#define ENVLENGTH 40
#define ENVWIDTH  20

static int snack_head_x = 20; 
static int snack_head_y = 10;

static int snack_last_x = 0; 
static int snack_last_y = 0;

typedef enum{UP,LEFT,DOWN,RIGHT} DIRECTION;
typedef enum{YES,NO} ISFOOD;
typedef struct food{
    int x;
    int y;
    ISFOOD f;
}food;

static food sfood;

static DIRECTION AIM = RIGHT;
static DIRECTION oldAIM;

const char snacknode = '@';

LIST_HEAD SHEAD;

typedef struct snack{
    int x;
    int y;
    LIST_HEAD snode;
}snack;

int ifinsnack(int x,int y)
{
    snack *pos;
    int st = 0;
    ListForEachEntry(snack,pos,(SHEAD.Next), snode)
    {
        if(pos->x == x && pos->y == y)
        {
            st = 1;
            break;
        }
    }
    return st;
}

void add_food()
{
    snack *pos; 

    while(1)
    {
        srand((int)time(0));
        sfood.x=2+(int)(rand()%(ENVLENGTH-2));
        srand(sfood.x);
        sfood.y=2+(int)(rand()%(ENVWIDTH-2));

        if(ifinsnack(sfood.x,sfood.y) == 0)
            break;
    }

    gotoxy_putc(sfood.x,sfood.y,'$');
    sfood.f = YES;
}

void add_snode(int x,int y)
{
    snack *sn = (snack*)malloc(sizeof(snack));
    sn->x = x;
    sn->y = y;
    ListAddTail(&(sn->snode),&SHEAD);
}

void initsnack()
{
    int x,y;
    INIT_LIST_HEAD(&SHEAD);
    add_snode(snack_head_x,snack_head_y);
    add_snode(snack_head_x-1,snack_head_y);
    add_snode(snack_head_x-2,snack_head_y);

    sfood.f = NO;
    for(x=1;x<=ENVLENGTH;x++)
    {
        gotoxy_putc(x,1,'*');
        gotoxy_putc(x,ENVWIDTH,'*');
    }
    for(y=1;y<=ENVWIDTH;y++)
    {
        gotoxy_putc(1,y,'*');
        gotoxy_putc(ENVLENGTH,y,'*');
    }
    gotoxy_puts(ENVLENGTH+2,3,"欢迎来到魔蛇峡谷");
    gotoxy_puts(ENVLENGTH+2,5,"w(W) 向上移动");
    gotoxy_puts(ENVLENGTH+2,7,"a(A) 向左移动");
    gotoxy_puts(ENVLENGTH+2,9,"s(S) 向下移动");
    gotoxy_puts(ENVLENGTH+2,11,"d(D) 向右移动");
    gotoxy_puts(ENVLENGTH+2,11,"q(Q) 退出游戏");
    gotoxy_puts(ENVLENGTH+2,13,"预祝您玩的愉快");
    gotoxy_puts(ENVLENGTH+2,15,"后续游戏功能会持续更新");
    gotoxy_puts(ENVLENGTH+2,17,"也欢迎各位大神优化一下");
}

void showsnack()
{
    snack *pos; 
    ListForEachEntry(snack,pos,&SHEAD, snode)
        gotoxy_putc(pos->x,pos->y,snacknode);
    gotoxy_putc(snack_last_x,snack_last_y,' ');
}

void movesnack()
{
    snack *pos,*posr;
    LIST_HEAD *p = SHEAD.Prev;
    pos = list_entry((p),snack,snode);
    snack_last_x = pos->x;
    snack_last_y = pos->y;
    while(p->Prev != &SHEAD)
    {
        pos = list_entry((p),snack,snode);
        posr = list_entry((p->Prev),snack,snode);
        pos->x = posr->x;
        pos->y = posr->y;
        p = p->Prev;
    }
    pos = list_entry((p),snack,snode);
    pos->x = snack_head_x;
    pos->y = snack_head_y;
}

void ifremove()
{

    if(AIM == UP)
    {
        if(oldAIM == DOWN)
            AIM = oldAIM;
    }
    if(AIM == DOWN)
    {
        if(oldAIM == UP)
            AIM = oldAIM;
    }
    if(AIM == LEFT)
    {
        if(oldAIM == RIGHT)
            AIM = oldAIM;
    }
    if(AIM == RIGHT)
    {
        if(oldAIM == LEFT)
            AIM = oldAIM;
    }
}

int ifout()
{   
    if(snack_head_x > 1 && snack_head_x <  ENVLENGTH &&
       snack_head_y > 1 && snack_head_y <  ENVWIDTH   )
    {
        return 0;
    }
    else
        return 1;
}



void run()
{
    int st = 1;
    char c = 0;

    for(;;)
    {
        usleep(400*1000);
        if(sfood.f == NO)
            add_food();
        c = 0;
        c = readch();
        oldAIM = AIM;
        if(c)
        {
            if(c == 'q'){
                return ;
            }
            if(c == 'w' || c == 'W')
                AIM = UP;
            if(c == 'a' || c == 'A')
                AIM = LEFT;
            if(c == 's' || c == 'S')
                AIM = DOWN;
            if(c == 'd' || c == 'D')
                AIM = RIGHT;
        }
        ifremove();
        gotoxy_putc(snack_head_x,snack_head_y,' ');
        if(AIM == UP)
            snack_head_y -= 1;
        if(AIM == LEFT)
            snack_head_x -= 1;
        if(AIM == DOWN)
            snack_head_y += 1;
        if(AIM == RIGHT)
            snack_head_x += 1;
        if(snack_head_x == sfood.x && snack_head_y == sfood.y)
        {
            add_snode(0,0);
            sfood.f = NO;
        }
        movesnack();
        showsnack();

        if(ifout())  break;
        if(ifinsnack(snack_head_x,snack_head_y))  break;
    }
    gotoxy_puts(20,10,"宝宝还需努力哦");
    gotoxy_puts(20,11,"Enter键推出");
    getchar();
}

int main()
{
    initkey();
    initsnack();
    run();
    relaykey();
    clrter("clear");
    return 0;
}

效果图如下：
这里写图片描述

各位大神快来优化吧！

暮紫川
关注
专栏目录
C语言贪吃蛇Linux版
小川先生的博客
12-20 4245
/* ======================================= */Update: 20170713新版贪吃蛇：传送门/* ======================================= */ 最近闲来无事用C语言写了个贪吃蛇解解闷, 其实这玩意儿也不难写, 其一就是如何绘制蛇和背景, 其二就是怎么把用户的输入实现成蛇的转向. 我这里使用了curses.h
Linux下纯C的贪吃蛇
09-05
这个程序是Linux下的纯C语言开发的一款贪吃蛇软件，下载后直接运行snake.sh(./snake.sh)即可，（如果没有权限可以用chmod 777 snake.sh加上权限）。 如果还有其他的疑问可以随时给我留言，我会尽我所能的解答亲的问题。
[源码] Linux C 贪吃蛇
08-18
Linux 下用C语言写的贪吃蛇 用到了 pthread 和curses 用gcc -lpthread -lcurses 编译
Linux C编程连载【6】- “混沌”贪吃蛇
di0808的博客
11-10 146
【任务】利用混沌随机数实现贪吃蛇游戏。 【解析】 【分析】 (1) 采用Lorenz 混沌映射 根据混沌时间序列的非周期性，改变迭代次数则会产生伪随机的运算结果。将时间(微秒) 向正的方向平移j(j>0)，作为Lorenz映射的迭代因子，则迭代次数的范围为[j,j+1...
linuxC下的贪吃蛇游戏
03-30
编译的时候记得把两个".c"文件一起编译了，然后运行，当然代码有改进的地方，这个用的时候自己改进一下啦
Ubuntu命令行贪吃蛇程序开发：多线程与Curses库应用
"Ubuntu下使用命令行编写贪吃蛇游戏，主要涉及C语言编程、多线程技术、Linux环境以及ncurses库的使用。" 在Ubuntu操作系统中，使用命令行界面编写游戏，如贪吃蛇，是一项挑战性的任务，特别是对于初学者而言。在这...
C语言实现Linux下的贪吃蛇游戏教程
通过这份文档，读者可以学习到如何使用C语言在Linux环境中开发一个经典的贪吃蛇游戏，包括基本的数据结构设计、游戏逻辑实现以及如何利用多线程技术优化用户体验。这对于提升编程技能，尤其是C语言和并发编程能力...
linux下贪吃蛇小游戏Demo
09-17
6. **多线程**：在某些实现中，游戏逻辑和用户输入处理可能会在不同的线程中进行，以提高响应性。 7. **事件驱动编程**：Linux下的`ncurses`库或者Python的`curses`模块可以用于实现基于终端的图形界面，它们允许...
linux平台c语言实现贪吃蛇小游戏
03-09
编译命令 gcc snake.c -lncurses -lpthread
基于c语言在linux下贪吃蛇项目
12-29
在Linux虚拟机下用c语言写的一个贪吃蛇游戏项目，源于一个游戏教学开发项目工程，可下载运行提供学习借鉴，供有C语言基础和linux基础的学习，有界面化制作，算法的编写。
Linux下纯C语言 多线程 人机 贪吃蛇
07-22
新手初学Linux c 写的多线程人机一起的贪吃蛇，终端玩耍，解压，make，gcc就可以了，写的很差大神批评指正
Linux贪吃蛇
04-15
应付计算机系大学生的作业或者实训课最佳之选，本作者考虑到你们编写文档报告的问题。先说明，网上绝对找不到第二个类似的程序，本作者学习时亲自开发的。解压后有4个文件，其中testncur.c是贪吃蛇源代码，有中文注释，极易上手，代码可读性极强，不用担心看不懂。其中有编写好的Makefile，下载后，解压将得到testncur_stu文件夹，文件夹通过共享方式或者ftp，samba方式，移动到虚拟机的linux下，使用cd命令进入testncur_stu文件夹中，执行清除命令make clean，然后再执行make，生成testncur文件，使用 ./testncur 执行该文件。可用做应付作业哟，代码有中文注释，针对小白编写报告时用的，本作者就帮到这里吧，搜索到本资源就是你的福气。
Linux环境下贪吃蛇游戏
08-20
Linux环境下贪吃蛇源代码，基于C语言实现的。用到知识点包括双链表，文件操作，frame buffer接口，键盘接口等等。实现了随机生成实物，游戏暂停，运行，退出状态显示，退出时提示是否保存，下次运行时可以加载。也可以手动设定起始长度，起始速度，以及速度和成绩的显示。
完整Linux C制作贪吃蛇代码
11-24
这是本人Linux下编写的贪吃蛇，基本完成功能，如果有不完善和改进之处请和我联系
Linux下贪吃蛇的c语言实现
weixin_53762042的博客
12-18 1852
#include<curses.h> #include<stdlib.h> #include<pthread.h> #include<unistd.h> #define UP 1 #define DOWN -1 #define LEFT 2 #define RIGHT -2 struct Snake{ int hang; int lie; struct Snake*next; };//声明贪吃蛇结点的结构体 struct Snake*head=NU
linuxC环境下的贪吃蛇游戏
qq_39597035的博客
03-21 766
linuxC环境下的贪吃蛇游戏先说两句项目需求分析实现思路以及架构使用进程分工实现功能（主体框架）元素定义 先说两句 这是我人生第一个C项目，也是我大学和我女友做的第一个C项目；项目虽然实现的不完美也有许多漏洞，也希望各位读者朋友轻喷，要看看代码，可以直接翻代码，下面我有附上项目代码。以上 项目需求分析 1.游戏元素包括：沙盘，墙壁，贪吃蛇，食物以及空位 2.需要实现键盘接收指令控制贪吃蛇移动，不...
linux下C实现贪吃蛇
weixin_43536181的博客
05-12 288
闲着没事，又刚学了AIO，就想试试写个贪吃蛇。 但后来也没时间做修改和优化了。写之前其实也每想好怎么写，写得蛮丑陋的，随便看看吧。 main.c文件如下 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <curses.h> #include "greedysnack.h" int main(){ Set_Win(); Start_Game(); getch();
Linux C贪吃蛇(单链表)
H2OzzZZ的博客
01-04 488
Linux C贪吃蛇(单链表) 功能 Terminal显示游戏区域，蛇，食物，分数。 蛇只能在限定区域内移动，即碰墙，游戏结束；不允许蛇碰撞自己身体，否则游戏结束，其中包括往蛇头180°方向运动，即蛇头朝右移动时按A使蛇180°转向。 食物分"✶",“❉”,“☯”,"✡"四种，依次是10-40分，蛇吃到任意食物会变长一格。 游戏分数达到100之后蛇移动速度会加快，同时每次场上会出现两个食物，吃到...
【Linux】C语言——贪吃蛇
m0_51706315的博客
07-19 955
【Linux】C语言——贪吃蛇
Java实现贪吃蛇游戏：多线程与自定义颜色
"这是一个Java实现的贪吃蛇游戏，它具有多线程特性，允许用户设置游戏界面的颜色，包括墙、底色和蛇的颜色。游戏支持正常暂停，并且提供了1到9个不同的游戏等级。此外，游戏框架还包含了键盘监听和菜单功能，如开始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值