六、蛇根据键盘方向键移动

最新推荐文章于 2024-05-20 17:15:16 发布
最新推荐文章于 2024-05-20 17:15:16 发布
阅读量20 收藏
点赞数
分类专栏： C语言 贪吃蛇 文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51972895/article/details/132012233
版权

前因：

main()中有两个while(1)循环问题

一是不断获取用户输入键盘所需要的键盘响应；

二是蛇不断的进行移动；

解决方法------Linux线程中有专有的函数

解决双while(1)的问题：

1 #include<curses.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<pthread.h>
  5 
  6 struct NodeofSnake
  7 {
  8         int hang;
  9         int lie;
 10         struct NodeofSnake *next;
 11 };
 12 
 13 struct NodeofSnake *head=NULL;
 14 struct NodeofSnake *tail=NULL;
 15 int key;
 16 
 17 void addNode()
 18 {
 19         struct NodeofSnake *new;
 20         new=(struct NodeofSnake*)malloc(sizeof(struct NodeofSnake));
 21         new->hang=tail->hang;
 22         new->lie =tail->lie+1;
 23         new->next=NULL;
 24 
 25         tail->next=new;
26         tail=new;
 27 }
 28 void initSnake()
 29 {
 30         struct NodeofSnake *point =head;
 31         if(point!=NULL){
 32                 head=head->next;
 33                 free(point);
 34         }
 35         head=(struct NodeofSnake*)malloc(sizeof(struct NodeofSnake));
 36         head->hang=2;
 37         head->lie =2;
 38         head->next=NULL;
 39 
 40         tail=head;
 41 
 42         addNode();
 43         addNode();
 44         addNode();
 45 }
 46 int wheatherOfSnakeNode(int hang,int lie)
 47 {
 48 
 49         struct NodeofSnake *point = head;
 50         while(point!=NULL){
51                 if(hang==point->hang && lie==point->lie ){
 52                         printw("[]");
 53                         return 1;
 54                 }
 55                 point=point->next;
 56         }
 57         return 0;
 58 }
 59 
 60 void initMap()
 61 {
 62         int hang=0;
 63         int lie =0;
 64         move(0,0);
 65 
 66         for(hang=0;hang<=20;hang++){
 67                 if(hang==0||hang==20){
 68                         for(lie=0;lie<20;lie++){
 69                                 printw("--");
 70                         }
 71                         printw("\n");
 72                 }
 73                 if(hang>0&&hang<=19){
 74                         for(lie=0;lie<=20;lie++){
 75                                 if(lie==0||lie==20){
76                                         printw("|");
 77                                 }else if(wheatherOfSnakeNode(hang,lie)){
 78                                 }
 79                                 else{
 80                                         printw("  ");
 81                                 }
 82                         }
 83                         printw("\n");
 84                 }
 85         }
 86         printw("By:GuoMing,key=%d\n",key);
 87 //      printw("key=%d\n",key);
 88 }
 89 void deleteNode()
 90 {
 91         struct NodeofSnake *point = head;
 92         head=head->next;
 93         free(point);
 94 }
 95 void snakeMove()
 96 {
 97         addNode();
 98         deleteNode();
 99         if(tail->lie==20 ||tail->lie==0 ||tail->hang==0 ||tail->hang==20 ){
100                 initSnake();
101         }
102 }
103 
104 void* refreshJieMian()
105 {
106         while(1){
107                 snakeMove();
108                 initMap();
109 
110                 refresh();
111                 usleep(100000);
112         }
113 
114 }
115 
116 void* changeDir()
117 {
118 //      int key;
119         while(1){                 //alway input keyboard.
120                 key=getch();
121                 //              printw("key=%d\n",key);
122 
123                 switch(key){
124                         case KEY_DOWN:
125                                 printw("DOWN\n");
126                                 break;
127                         case KEY_UP:
128                                 printw("UP\n");
129                                 break;
130                         case KEY_LEFT:
131                                 printw("LEFT\n");
132                                 break;
133                         case KEY_RIGHT:
134                                 printw("RIGHT\n");
135                                 break;
136                 }
137         }
138 }
139 
140 int main()
141 {
142         pthread_t t1,t2 ;
143         initscr();
144         keypad(stdscr,1);
145 
146         initSnake();
147         initMap();
148         pthread_create(&t1,NULL,refreshJieMian,NULL);
149         pthread_create(&t2,NULL,changeDir,NULL);
150 151         while(1);
152         getch();
153         endwin();
154 
155         return 0;
156 }

 key值可以把你按下的东西打印出来

蛇根据方向键运动（但发现有bug）

  1 #include<curses.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<pthread.h>
  5 
  6 #define UP    1
  7 #define DOWN  2
  8 #define LEFT  3
  9 #define RIGHT 4
 10 
 11 struct NodeofSnake
 12 {
 13         int hang;
 14         int lie;
 15         struct NodeofSnake *next;
 16 };
 17 
 18 struct NodeofSnake *head=NULL;
 19 struct NodeofSnake *tail=NULL;
 20 int key;
 21 int dir;
 22 
 23 void addNode()
 24 {
 25         struct NodeofSnake *new;
 26         new=(struct NodeofSnake*)malloc(sizeof(struct NodeofSnake));
 27         new->next=NULL;
 28 
 29         switch(dir){
 30                 case UP:
 31                         new->hang=tail->hang-1;
 32                         new->lie =tail->lie;
 33                         break;
 34                 case DOWN:
 35                         new->hang=tail->hang+1;
 36                         new->lie =tail->lie;
 37                         break;
 38                 case LEFT:
 39                         new->hang=tail->hang;
 40                         new->lie =tail->lie-1;
 41                         break;
 42                 case RIGHT:
 43                         new->hang=tail->hang;
 44                         new->lie =tail->lie+1;
 45                         break;
 46         }
 47 
 48         tail->next=new;
 49         tail=new;
 50 }
 51 void initSnake()
 52 {
 53         dir=RIGHT;
 54         struct NodeofSnake *point =head;
 55         if(point!=NULL){
 56                 head=head->next;
 57                 free(point);
 58         }
 59         head=(struct NodeofSnake*)malloc(sizeof(struct NodeofSnake));
 60         head->hang=2;
 61         head->lie =2;
 62         head->next=NULL;
 63 
 64         tail=head;
 65 
 66         addNode();
 67         addNode();
 68         addNode();
 69 }
 70 int wheatherOfSnakeNode(int hang,int lie)
 71 {
 72 
 73         struct NodeofSnake *point = head;
 74         while(point!=NULL){
 75             76                         printw("[]");
 77                         return 1;
 78                 }
 79                 point=point->next;
 80         }
 81         return 0;
 82 }
 83 
 84 void initMap()
 85 {
 86         int hang=0;
 87         int lie =0;
 88         move(0,0);
 89 
 90         for(hang=0;hang<=20;hang++){
 91                 if(hang==0||hang==20){
 92                         for(lie=0;lie<20;lie++){
 93                                 printw("--");
 94                         }
 95                         printw("\n");
 96                 }
 97                 if(hang>0&&hang<=19){
 98                         for(lie=0;lie<=20;lie++){
 99                                 if(lie==0||lie==20){
100                                         printw("|");
101                                 }else if(wheatherOfSnakeNode(hang,lie)){
102                                 }
103                                 else{
104                                         printw("  ");
105                                 }
106                         }
107                         printw("\n");
108                 }
109         }
110         printw("By:GuoMing,key=%d\n",key);
111         //      printw("key=%d\n",key);
112 }
113 void deleteNode()
114 {
115         struct NodeofSnake *point = head;
116         head=head->next;
117         free(point);
118 }
119 void snakeMove()
120 {
121         addNode();
122         deleteNode();
123         if(tail->lie==20 ||tail->lie==0 ||tail->hang==0 ||tail->hang==20 ){
124                 initSnake();
125         }
126 }
127 
128 void* refreshJieMian()
129 {
130         while(1){
131                 snakeMove();
132                 initMap();
133 
134                 refresh();
135                 usleep(100000);
136         }
137 
138 }
139 
140 void* changeDir()
141 {
142         //      int key;
143         while(1){                 //alway input keyboard.
144                 key=getch();
145                 //              printw("key=%d\n",key);
146 
147                 switch(key){
148                         case KEY_DOWN:
149                                 dir=DOWN;
150                                 break;
151                         case KEY_UP:
152                                 dir=UP;
153                                 break;
154                         case KEY_LEFT:
155                                 dir=LEFT;
156                                 break;
157                         case KEY_RIGHT:
158                                 dir=RIGHT;
159                                 break;
160                 }
161         }
162 }
163 
164 int main()
165 {
166         pthread_t t1,t2 ;
167         initscr();
168         keypad(stdscr,1);
169 
170         //      dir=RIGHT;             forbid initdir ,cause:only one use.
171         initSnake();
172         initMap();
173         pthread_create(&t1,NULL,refreshJieMian,NULL);
174         pthread_create(&t2,NULL,changeDir,NULL);
175 
176         while(1);
177         getch();
178         endwin();
179 
180         return 0;

蛇运动方向根据方向键运动（无bug）

1 #include<curses.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<pthread.h>
  5 
  6 #define UP    1
  7 #define DOWN  -1
  8 #define LEFT  2
  9 #define RIGHT -2
 10 
 11 struct NodeofSnake
 12 {
 13         int hang;
 14         int lie;
 15         struct NodeofSnake *next;
 16 };
 17 
 18 struct NodeofSnake *head=NULL;
 19 struct NodeofSnake *tail=NULL;
 20 int key;
 21 int dir;
 22 
 23 void addNode()
 24 {
 25         struct NodeofSnake *new;
26         new=(struct NodeofSnake*)malloc(sizeof(struct NodeofSnake));
 27         new->next=NULL;
 28 
 29         switch(dir){
 30                 case UP:
 31                         new->hang=tail->hang-1;
 32                         new->lie =tail->lie;
 33                         break;
 34                 case DOWN:
 35                         new->hang=tail->hang+1;
 36                         new->lie =tail->lie;
 37                         break;
 38                 case LEFT:
 39                         new->hang=tail->hang;
 40                         new->lie =tail->lie-1;
 41                         break;
 42                 case RIGHT:
 43                         new->hang=tail->hang;
 44                         new->lie =tail->lie+1;
 45                         break;
 46         }
 47 
 48         tail->next=new;
 49         tail=new;
 50 }
51 void initSnake()
 52 {
 53         dir=RIGHT;
 54         struct NodeofSnake *point =head;
 55         if(point!=NULL){
 56                 head=head->next;
 57                 free(point);
 58         }
 59         head=(struct NodeofSnake*)malloc(sizeof(struct NodeofSnake));
 60         head->hang=2;
 61         head->lie =2;
 62         head->next=NULL;
 63 
 64         tail=head;
 65 
 66         addNode();
 67         addNode();
 68         addNode();
 69 }
 70 int wheatherOfSnakeNode(int hang,int lie)
 71 {
 72 
 73         struct NodeofSnake *point = head;
 74         while(point!=NULL){
 75                 if(hang==point->hang && lie==point->lie ){
76                         printw("[]");
 77                         return 1;
 78                 }
 79                 point=point->next;
 80         }
 81         return 0;
 82 }
 83 
 84 void initMap()
 85 {
 86         int hang=0;
 87         int lie =0;
 88         move(0,0);
 89 
 90         for(hang=0;hang<=20;hang++){
 91                 if(hang==0||hang==20){
 92                         for(lie=0;lie<20;lie++){
 93                                 printw("--");
 94                         }
 95                         printw("\n");
 96                 }
 97                 if(hang>0&&hang<=19){
 98                         for(lie=0;lie<=20;lie++){
 99                                 if(lie==0||lie==20){
100                                         printw("|");
101                                 }else if(wheatherOfSnakeNode(hang,lie)){
102                                 }
103                                 else{
104                                         printw("  ");
105                                 }
106                         }
107                         printw("\n");
108                 }
109         }
110         printw("By:GuoMing,key=%d\n",key);
111         //      printw("key=%d\n",key);
112 }
113 void deleteNode()
114 {
115         struct NodeofSnake *point = head;
116         head=head->next;
117         free(point);
118 }
119 void snakeMove()
120 {
121         addNode();
122         deleteNode();
123         if(tail->lie==20 ||tail->lie==0 ||tail->hang==0 ||tail->hang==20 ){
124                 initSnake();
125         }
126 }
127 
128 void* refreshJieMian()
129 {
130         while(1){
131                 snakeMove();
132                 initMap();
133 
134                 refresh();
135                 usleep(100000);
136         }
137 
138 }
139 
140 //use abs() to address direction question.
141 
142 void dirWheatherTurn(int direction)
143 {        //   origion       key now dir
144         if(abs(dir) != abs(direction)){
145                 dir=direction;
146         }
147 
148 }
149 
150 void* changeDir()
151 {
152         //      int key;
153         while(1){                 //alway input keyboard.
154                 key=getch();
155                 //              printw("key=%d\n",key);
156 
157                 switch(key){
158                         case KEY_DOWN:
159                                 dirWheatherTurn(DOWN);
160                                 break;
161                         case KEY_UP:
162                                 dirWheatherTurn(UP);
163                                 break;
164                         case KEY_LEFT:
165                                 dirWheatherTurn(LEFT);
166                                 break;
167                         case KEY_RIGHT:
168                                 dirWheatherTurn(RIGHT);
169                                 break;
170                 }
171         }
172 }
173 
174 int main()
175 {
176         pthread_t t1,t2 ;
177         initscr();
178         keypad(stdscr,1);
179 
180         //      dir=RIGHT;             forbid initdir ,cause:only one use.
181         initSnake();
182         initMap();
183         pthread_create(&t1,NULL,refreshJieMian,NULL);
184         pthread_create(&t2,NULL,changeDir,NULL);
185 
186         while(1);
187         getch();
188         endwin();
189 
190         return 0;
191 }

萧铭苦学编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS实现盒子跟着鼠标移动及键盘方向键控制盒子移动效果示例
10-17
主要介绍了JS实现盒子跟着鼠标移动及键盘方向键控制盒子移动效果,涉及javascript事件响应及页面元素属性动态操作相关实现技巧,需要的朋友可以参考下
python通过键盘方向键移动_移动python教程!python中怎么用键盘方向键控制方块的移动...
weixin_39909859的博客
12-05 1279
python中怎么用键盘方向键控制方块的移动感象是在用TKinter绘图。在tkinter里有一键射表。左键也在其中。KeyPress-xx这个xx是键盘的号码。不在button.tcl里。需己测试一下。用C语言的getch打印一下。python 图片移动#-*-coding:gbk-*-importImageimportImageDrawimportImageChopsim=I...
QT实现键盘方向键控制Label移动
weixin_44264668的博客
07-15 2107
keyboarddialog.h #ifndef KEYBOARDDIALOG_H #define KEYBOARDDIALOG_H #include <QDialog> #include <QKeyEvent> namespace Ui { class KeyboardDialog; } class KeyboardDialog : public QDialog { Q_OBJECT public: explicit KeyboardDialog(QWidg
Windows 使用键盘移动窗口
热门推荐
sigmarising的博客
03-05 2万+
Windows 使用键盘移动窗口 有时博主手一抖，就把应用程序的窗口拖到桌面外面了……只能关了再开。 所以本文介绍，如何使用键盘控制窗口移动。 Step1. 快捷键 Alt + Space 点击任务栏中要操作的应用程序，按下快捷键 Alt + Space，便可以开启一个菜单： 在这里插入图片描述 ...
如何解除计算机方向键问题,电脑键盘方向键错乱怎么处理
weixin_39661405的博客
07-25 2753
一、 电脑键盘按键错乱怎么回事?1.有可能是健盘里的健连在一起了,查看一下,如果有,用刀割开,即健与健之间那个缝里有一条小小的胶将两个健连在一起,割开就可恢复正常.2.有可能是病毒问题,将电脑所有软件舍了,再重装系统,然后装好杀毒软件,最好卡巴和360一起来,在安全模式下杀毒.3.有可能是连接健盘的主板处坏了.可以试下用其他好的健盘插上试试看,如果其他健盘没问题则要换健盘了,如果其他健盘也照样问题...
QT5.12案例 通过键盘方向键控制label移动
chenQYli的博客
07-01 910
QT5.12案例 通过键盘方向键控制label移动
易语言用滚动条和键盘方向键控制移动显示图片
08-21
用滚动条和键盘方向键控制移动显示图片系统结构:易语言用滚动条和键盘方向键控制移动显示图片源码,用滚动条和键盘方向键控制移动显示图片 ======窗口程序集1 || ||------_按钮4_被单击
Qt 方向键控制焦点移动，改变选中的控件
09-27
Qt 实现利用方向键控制光标在不同控件上移动（本资源控件为LineEdit），上下方向键可直接移动至上一个或下一个控件，左右方向键配合Ctrl键使用，本资源借鉴相关网络资源编写。
键盘的方向键控制矩形的移动
06-08
1. 掌握使用GDI进行绘图的原理 2. 使用CGDIObject及CDC类进行绘图 1. 设计一个SDI程序，绘制黄色矩形，可使用键盘的方向键控制矩形的移动，要保证矩形不得移到客户区外。 注：使用GetClientRect()获得客户区区域。
C语言：double类型，处理小数的利器
爱编程的鱼的博客
05-17 322
​double​是 C语言中用来存储双精度浮点数的一种重要数据类型，它可以帮助你处理带有小数点的数字。学习使用​double​是学习 C语言的重要一步，它将帮助你完成更多复杂的计算任务。希望这篇文章能够帮助你理解​double​的基本概念，并开始在你的 C语言程序中使用它！
Linux知识点笔记
exercise_smile的博客
05-16 850
Linux 主要的发行版(release):Ubuntu(乌班图)、 RedHat(红帽)、 CentOS、 Debain[蝶变]、 Fedora、 SuSE、 OpenSUSE [示意图]在 linux 中的每个用户必须属于一个组， 不能独立于组外。在 linux 中每个文件 有所有者、 所在组、 其它组的概念。ls -l 中显示的内容如下：0-9 位说明：第 0 位确定文件类型(d, - , l , c , b)l 是链接， 相当于 windows 的快捷方式。
Linux 三十六章
一怀明月的博客
05-17 982
信号量 sem_init sem_destroy sem_wait sem_post 基于环形队列的CP问题 环形队列的生产者消费者模型 线程池 localtime时间戳转化 mkdir系统调用 bind绑定成员函数 懒汉饿汉单例模式 懒汉模式： 饿汉模式： 懒汉和饿汉相同点： 线程池源码实现
Linux “如何添加用户/组和修改用户/组”
y2162484776的博客
05-20 365
我们首先要知道Linux中用户时必须的吗！？？？用户是标识计算机的资源归属的。
操作系统 实验13 批处理操作接口3：引用与命令替换
m0_63093530的博客
05-14 151
结果：第一个和第三个命令是错的，第二个和第四个命令是对的。echo "这是命令替换形式1...$date1"echo "$sv ++++加上另一些字符！2、输出字符串“China's panda”命令：echo China\'s panda。6、将命令date执行结果赋予变量date1。7、将命令date执行结果赋予变量date2。1、输出字符串“$Dollar”命令：echo \$Dollar。命令：date2=$(date)命令：date1=`date`
Windows、Linux添加路由
刘某的博客
05-20 176
路由添加、修改、删除的基本命令
一文读懂Linux
2401_83060956的博客
05-20 739
为了便于理解，本文从常用操作和概念开始讲起。虽然已经尽量做到简化，但是涉及到的内容还是有点多。在面试中，Linux 知识点相对于网络和操作系统等知识点而言不是那么重要，只需要重点掌握一些原理和命令即可。
Linux的基础指令
asdssadddd的博客
05-14 944
常用选项:-f 或 --force 强行复制文件或目录, 不论目的文件或目录是否已经存在.-i 或 --interactive覆盖文件之前先询问用户.-r递归处理, 将指定目录下的文件与子目录一并处理. 若源文件或目录的形态, 不属于目录或符号链接, 则一律视为普通文件处理.-R 递归处理, 将指定目录下的文件及子目录一并处理.
【Linux】-Zookeeper安装部署[17]
weixin_63106307的博客
05-20 279
除了为Hadoop和Hbase提供协调服务外，ZooKeeper也被其他软件采用作为其分布式状态一致性的依赖，比如Kafka，又或者一些软件项目中，也经常能见到ZooKeeper作为一致性协调服务存在。10、【在node1、node2、node3上分别执行】启动zookeeper。11、【在node1、node2、node3上分别执行】检查zookeeper。7、【node1上操作】 将zookeeper 复制到node2和node3。2、【node1上操作】下载ZooKeeper安装包，并解压。
【linux】详解vim编辑器
最新发布
2301_79796701的博客
05-20 435
通用的配置再插入模式下就像一个记事本一样，如果要写代码，写文本会很不舒服，而用户可以额外的为vim添加其他配置。在目录 /etc/ 下面，有个名为vimrc的文件，这是系统中公共的vim配置文件,对所有用户都有效。文件保存或退出，也可以进行文件替换，找字符串，列出行号等操作。」号表示一个数字，在冒号后输入一个数字，再按回车键就会跳到该行了，如输入数字。」键，再输入您想寻找的字符，如果第一次找的关键字不是您想要的，可以一直按「n。」键，再输入您想寻找的字符，如果第一次找的关键字不是想要的，可以一直按。
用python3实现键盘方向键映射鼠标移动的脚本
05-19
可以使用模块`pyautogui`来实现这个脚本。 首先，安装模块`pyautogui`： ...当用户按下键盘方向键时，根据映射关系计算出鼠标移动的距离，并使用`pyautogui.moveRel()`函数移动鼠标。当用户按下`Ctrl+C`时，退出循环。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值