设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › 学习了ncurses绘图库的一些函数的使用方法
返回列表 发新帖
查看: 1674|回复: 2

[技术交流] 学习了ncurses绘图库的一些函数的使用方法

[复制链接]
就是要努力呀
发表于 2020-3-9 12:37:08 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
本帖最后由 就是要努力呀 于 2020-3-9 12:37 编辑
  1. #include <stdio.h>
  2. #include <ncurses.h>

  4. int main(void)
  5. {
  6.         initscr();      /*      */
  7.         cbreak();       /*初始化ncurses(再使用ncurses库的都要先调用这三个函数)*/
  8.         noecho();       /*      */

  10.         curs_set(0);    //隐藏光标

  12.         move(10, 10);   //移动光标
  13.         addch('A');     //打印一个字符
  14.         addstr("ABCD"); //打印一串字符串
  15.         refresh();      //刷新屏幕

  17.         getch();        //类似于getchar() 但getch()会在用户按键后立刻执行 不需要等待回车

  19.         endwin();       //退出ncurses

  21.         return 0;
  22. }
复制代码
感谢人造人大佬给我提出的ncurse函数库
今天在b站通过学习一位up主写flappybird这个游戏学习了ncurses库的一些使用方法，在这里分享给大家
ncurse库不是linux自带的库，所以需要在命令行执行 sudo apt-get install libncurses5-dev 安装这个库
在编译的时候也需要加上-lncurese选项连接这个库

以下是flappybird的代码 因为是一边跟着up写的 所以就没有注释
  1. #include <stdio.h>
  2. #include <ncurses.h>
  3. #include <stdlib.h>
  4. #include <signal.h>
  5. #include <sys/time.h>

  7. #define BIRD 'o'
  8. #define PIPE '*'
  9. #define BLANK ' '

  11. typedef struct Pipe
  12. {
  13.         int x;
  14.         int y;
  15.         struct pipe *next;
  16. }
  17. Pipe;

  19. Pipe *HEAD, *TAIL;

  21. int X, Y;        //小鸟坐标
  22.                
  23. void drop(int sig); 小鸟下坠
  24. int set_ticker(int n_msec); 设定时间发送信号
  25. void clear_bird(); 清楚小鸟之前的位置
  26. void draw_bird(); 打印出小鸟现在的位置
  27. void clear_pipe(int x, int y); 清除一个柱子之前的位置
  28. void draw_pipe(int x, int y); 打印一个柱子现在的位置
  29. void init_pipes(); 初始化柱子的链表
  30. void draw_pipes(); 打印所有柱子
  31. void clear_pipes(); 清除所有柱子
  32. void move_pipes(); 移动所有柱子

  34. void move_pipes()
  35. {
  36.         Pipe *p;

  38.         for(p = HEAD->next; p->next != NULL; p = p->next)
  39.         {
  40.                 p->x--;
  41.         }
  42. }

  44. void draw_pipes()
  45. {
  46.         Pipe *p;

  48.         for(p = HEAD->next; p->next != NULL; p = p->next)
  49.         {
  50.                 draw_pipe(p->x, p->y);
  51.         }
  52. }

  54. void clear_pipes()
  55. {
  56.         Pipe *p;

  58.         for(p = HEAD->next; p->next != NULL; p = p->next)
  59.         {
  60.                 clear_pipe(p->x, p->y);
  61.         }
  62. }

  64. void init_pipes()
  65. {
  66.         HEAD = (Pipe *)malloc(sizeof(Pipe));

  68.         if(HEAD == NULL)
  69.         {
  70.                 exit(0);
  71.         }

  73.         HEAD->next = NULL;

  75.         Pipe *temp, *p = HEAD;
  76.         int i;

  78.         for(i = 0; i < 5; i++)
  79.         {
  80.                 temp = (Pipe *)malloc(sizeof(Pipe));

  82.                 if(temp == NULL)
  83.                 {
  84.                         exit(0);
  85.                 }

  87.                 temp->x = (i + 1) * 20;
  88.                 temp->y = rand()%16 + 10;

  90.                 p->next = temp;
  91.                 temp->next = NULL;
  92.                 p = temp;
  93.         }

  95.         TAIL = p;
  96. }

  98. void draw_pipe(int x, int y)
  99. {
  100.         int i, j;

  102.         for(i = 0; i < 5; i++)
  103.         {
  104.                 for(j = 0; j < 20; j++)
  105.                 {
  106.                         move(y - j - 5, x + i);
  107.                         addch(PIPE);

  109.                         move(y + j + 5, x + i);
  110.                         addch(PIPE);
  111.                 }
  112.         }
  113. }

  115. void clear_pipe(int x, int y)
  116. {       
  117.         int i, j;

  119.         for(i = 0; i < 5; i++)
  120.         {
  121.                 for(j = 0; j < 20; j++)
  122.                 {
  123.                         move(y - j - 5, x + i);
  124.                         addch(BLANK);

  126.                         move(y + j + 5, x + i);
  127.                         addch(BLANK);
  128.                 }
  129.         }

  131. }

  133. void draw_bird()
  134. {
  135.         move(X, Y);
  136.         addch(BIRD);
  137.         refresh();

  139.         if((char)inch() == PIPE)
  140.         {
  141.                 set_ticker(0);
  142.                 endwin();
  143.                 exit(0);
  144.         }
  145. }

  147. void clear_bird()
  148. {
  149.         move(X, Y);
  150.         addch(' ');
  151.         refresh();
  152. }

  154. int set_ticker(int n_msec)
  155. {
  156.         struct itimerval timeset;
  157.         long int n_sec, n_usec;

  159.         n_sec = n_msec / 1000;
  160.         n_usec = (n_msec % 1000) * 1000L;

  162.         timeset.it_interval.tv_sec = n_sec;
  163.         timeset.it_interval.tv_usec = n_usec;

  165.         timeset.it_value.tv_sec = n_sec;
  166.         timeset.it_value.tv_usec = n_usec;

  168.         return setitimer(ITIMER_REAL, ×et, NULL);
  169. }

  171. void drop(int sig)
  172. {
  173.         clear_bird();

  175.         X++;

  177.         draw_bird();

  179.         clear_pipes();

  181.         Pipe *p = HEAD->next;

  183.         if(p->x < 0)
  184.         {
  185.                 HEAD->next = p->next;

  187.                 free(p);

  189.                 Pipe *temp = (Pipe *)malloc(sizeof(Pipe));

  191.                 if(temp == NULL)
  192.                 {
  193.                         exit(0);
  194.                 }

  196.                 temp->x = 80;
  197.                 temp->y = 15;
  198.                 TAIL->next = temp;
  199.                 temp->next = NULL;
  200.                 TAIL = temp;
  201.         }

  203.         move_pipes();
  204.         draw_pipes();
  205. }

  207. int main(void)
  208. {
  209.         int i;
  210.         char ch;

  212.         X = 5;
  213.         Y = 10;

  215.         initscr();
  216.         cbreak();
  217.         noecho();
  218.         curs_set(0);
  219.         srand(time(NULL));
  220.        
  221.         signal(SIGALRM, drop);
  222.         set_ticker(500);

  224.         init_pipes();

  226.         while(true)
  227.         {
  228.                 clear_bird();
  229.                 draw_bird();
  230.                 clear_pipes();
  231.                 draw_pipes();

  233.                 if((ch = getch()) == ' ')
  234.                 {
  235.                         clear_bird();

  237.                         X--;
  238.                 }
  239.                 else if(ch == 'q' || ch == 'Q')
  240.                 {
  241.                         break;
  242.                 }
  243.         }

  245.         endwin();
  246.        
  247.         return 0;
  248. }
复制代码
当然自己也有很多没有弄明白的地方
<sys/time.h>头文件
signal函数 signal(SIGALRM, drop)（我知道这个函数的意思是接受数据就执行drop函数）

还有set_ticker这个函数中定义的 itimerval 结构体
以及 setitimer函数 setitimer(ITIMER_REAL, &TIMESET, NULL) (指定多少时间后就发送信号)
因为视频中对这几个函数都是略过或者根本没讲 所以一点也没搞懂


小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

人造人
发表于 2020-3-9 14:16:24 | 显示全部楼层
参考这篇文章 https://blog.csdn.net/lixianlin/article/details/25604779

我看完这篇文章，一开始写下的测试代码是这样的
  1. #include <stdio.h>
  2. #include <signal.h>
  3. #include <sys/time.h>

  5. // 回调函数
  6. void handler(int sig)
  7. {
  8.     static int count;
  9.     printf("handler: %d\n", count++);
  10. }

  12. int main(void)
  13. {
  14.     // 注册回调函数
  15.     // 当程序收到SIGALRM信号后
  16.     // 暂停当前程序的执行，转去执行handler函数
  17.     // handler函数返回后再从暂停的位置继续向下执行
  18.     signal(SIGALRM, handler);
  19.     struct itimerval new_value;
  20.     new_value.it_interval.tv_sec = 0;
  21.     new_value.it_interval.tv_usec = 500000;
  22.     new_value.it_value.tv_sec = 0;
  23.     new_value.it_value.tv_usec = 0;
  24.    
  25.     // 设置定时器
  26.     // 当定时器超时后让系统发送一个信号给当前程序
  27.     // ITIMER_REAL参数指明要让系统发送SIGALRM信号
  28.     setitimer(ITIMER_REAL, &new_value, NULL);
  29.     while(1)
  30.         ;
  31.     return 0;
  32. }
复制代码


首先系统会在一个单位时间后对it_value递减，单位时间是多少，取决于你的系统，可能是10毫秒也可能是1毫秒，甚至是微妙、纳秒
总之就是系统会对it_value减一个合适的值，并不一定是减1，减多少取决于系统
系统每一个单位时间都对it_value减一个合适的值，直到it_value小于等于0
然后系统会做两件事
1.把it_interval复制到it_value，开始新一轮定时
2.发送一个信号，我们通过参数ITIMER_REAL要求发送SIGALRM

  1.     new_value.it_interval.tv_sec = 0;
  2.     new_value.it_interval.tv_usec = 500000;
  3.     new_value.it_value.tv_sec = 0;
  4.     new_value.it_value.tv_usec = 0;
复制代码


我期望的是500毫秒发一个信号
调用完setitimer函数后立刻发一个信号，因为it_value为0

但是系统不允许我这样做，系统会把一开始的it_value为0作为定时器停止的标志

那么修改代码
  1. #include <stdio.h>
  2. #include <signal.h>
  3. #include <sys/time.h>

  5. void handler(int sig)
  6. {
  7.     static int count;
  8.     printf("handler: %d\n", count++);
  9. }

  11. int main(void)
  12. {
  13.     signal(SIGALRM, handler);
  14.     struct itimerval new_value;
  15.     new_value.it_interval.tv_sec = 0;
  16.     new_value.it_interval.tv_usec = 500000;
  17.     new_value.it_value = new_value.it_interval;
  18.     setitimer(ITIMER_REAL, &new_value, NULL);
  19.     while(1)
  20.         ;
  21.     return 0;
  22. }
复制代码


让it_value直接等于it_interval，也就是不要一开始就发信号了
这样确实可以了，500ms发一次信号

不知道你是不是对 tv_sec 和 tv_usec 的设置有疑问
我是应该只设置tv_sec还是只设置tv_usec  ？
这两个是怎么表示时间的？

https://blog.csdn.net/lyc_daniel/article/details/11733715
“tv_sec为Epoch到创建struct timeval时的秒数，tv_usec为微秒数，即秒后面的零头”

看到 “秒后面的零头”，我明白了
这两个参数是一起表示时间的，就像是整数和小数分开存储一样
tv_sec存储秒，tv_usec存储微秒

那我又有了另一个问题，我能不能把tv_sec设置为0，通过设置tv_usec来定时任意时间？
  1. #include <stdio.h>
  2. #include <signal.h>
  3. #include <sys/time.h>

  5. void handler(int sig)
  6. {
  7.     static int count;
  8.     printf("handler: %d\n", count++);
  9. }

  11. int main(void)
  12. {
  13.     signal(SIGALRM, handler);
  14.     struct itimerval new_value;
  15.     new_value.it_interval.tv_sec = 0;
  16.     new_value.it_interval.tv_usec = 1000000;        // 1秒，6个0
  17.     new_value.it_value = new_value.it_interval;
  18.     setitimer(ITIMER_REAL, &new_value, NULL);
  19.     while(1)
  20.         ;
  21.     return 0;
  22. }
复制代码



通过测试是
不能这样，tv_sec 表示秒的部分
tv_usec只能表示微秒和毫秒，会忽略超过毫秒的部分

  1. #include <stdio.h>
  2. #include <signal.h>
  3. #include <sys/time.h>

  5. void handler(int sig)
  6. {
  7.     static int count;
  8.     printf("handler: %d\n", count++);
  9. }

  11. int main(void)
  12. {
  13.     signal(SIGALRM, handler);
  14.     struct itimerval new_value;
  15.     new_value.it_interval.tv_sec = 0;
  16.     new_value.it_interval.tv_usec = 100000;        // 100毫秒，5个0
  17.     new_value.it_value = new_value.it_interval;
  18.     setitimer(ITIMER_REAL, &new_value, NULL);
  19.     while(1)
  20.         ;
  21.     return 0;
  22. }
复制代码


这样是可以的
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

就是要努力呀
 楼主| 发表于 2020-3-9 16:43:53 From FishC Mobile | 显示全部楼层
人造人 发表于 2020-3-9 14:16
参考这篇文章 https://blog.csdn.net/lixianlin/article/details/25604779

我看完这篇文章，一开始写下 ...

好奥利给我会仔细看的
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-7-28 02:35

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表