信息安全系统设计基础课程实践：简单TUI游戏设计

时间 2019-11-26

原文原文链接

简单TUI游戏设计

	目录
一	Curses库简介与基本开发方法
二	事件驱动编程：编写一个视频游戏
三	弹球游戏的实现与优化
四	简单TUI游戏设计实践总结

1、Curses库简介与基本开发方法

1.Curses概述

curses其实是一个函数开发包，专门用来进行UNIX下终端环境下的屏幕界面处理以及I/O处理。经过这些函数库，C和C++程序就能够控制终端的视频显示以及输入输出。html
使用curses包中的函数，用户能够很是方便的建立和操做窗口，使用菜单以及表单，并且最为重要的一点是使用curses包编写的程序将独立于各类具体的终端，程序具备良好的移植性。node

（1）curses开发包内容

库名	描述	头文件
curses	最先的curses包只包含这一部分，主要控制屏幕的输入和输出，光标的操做，窗口的建立和操做等。	curses.h
panel	相似于窗口堆栈，不一样的窗口能够存放于其中，而且能够在其中进行移动。	panel.h
menu	新增的部分，主要包括建立菜单而且与之交互的函数，主要用来接受用户的选择。	menu.h
form	包括建立表单以及与之进行交互的函数，主要用来接受用户数据输入。	form.h

（2）curses包移植性

curses包的这种终端独立性归根于终端描述数据库terminfo和termcap。linux

终端描述数据库(Terminal Description Databases)
- terminfo(TERMinal INFOrmation database)
- termcap（TERMinal CAPabilitie database）

这两个数据库里存放了不一样终端的操做控制码和转义序列以及其他相关信息。ios

使用每个终端：数据库

- curses将首先在终端描述数据库中查找是否存在该类型的终端描述信息
  - 若是找到，则进行相应的处理。
  - 若是数据库中没有相应信息，则程序没法在该终端上运行，除非用户本身增长新的终端描述。

（3）安装与使用

安装编程
```
sudo apt-get install libncurses5-dev
```
若发现找不到这个包，可使用命令 sudo apt-get update 更新下包源。数组
```
gcc program.c -o program -lcurses
```
程序中使用curses库函数：引用curses库的头文件curses.h，即：缓存
```
#include <curses.h>
```
- 因为curses使用标准I/O，所以这个库一旦被引用，系统自动的将<stdio.h>和<unclt.h>一块儿包含进来，若是对于System V系统，<terminfo.h>也会包含进来，另外还可能包括<termios.h>、<termio.h>、<sgtty.h>，具体的由系统自己决定。
编译时加上-lcurses，用来在连接的时候提示连接程序将curses库连接进去。安全

2.Curses库常量定义

头文件curses.h中定义了四个整型常量，其中两个是大多数的curses函数的返回结果，另外两个是布尔类型的值，一旦包含了curses头文件，就能够在程序中直接使用它们。

整型常量	定义
OK	curses函数运行成功的返回值，系统定义为0
ERR	curses函数运行发生错误时候的返回值，系统定义为-1
TRUE	布尔值，表示为真，系统定义为1
FALSE	布尔值，表示为假，系统定义为0

3.标准屏幕与当前屏幕

（1）初始化

在主函数中设置了信号处理函数以后咱们就调用了initscr()，通常状况下在其他的curses函数被调用以前咱们就必须首先调用initscr()。数据结构

initscr()对curses包进行一些初始化的工做，并且在每个程序里面，这个函数只能调用一次。它的做用主要包括：

- 经过读取TERM环境变量的值来决定当前使用的终端类型，开启终端模式。
  - 根据终端的具体状况将终端的一些性能参数读进相关变量中，完成对相关数据结构的初始化工做，例如获取LINES和COLS的值。
  - 建立和初始化标准屏幕stdscr和当前屏幕curscr，同时为它们分配必要的存储空间。
  - 通知refresh()函数首次调用的时候可以清除屏幕。

（2）标准屏幕、当前屏幕

若是程序中使用了curses库，那么在程序初始化的时候，系统将自动产生两个默认屏幕。

第一个：标准屏幕，系统定义为stdscr，表明终端的整个屏幕区域。
  第二个：当前屏幕，系统定义为curscr，表明用户可以看到的屏幕显示。

curses库的屏幕刷新机制：
- 一般终端的刷新频率都不是很高，所以频繁的刷新可能致使显示速度很是的慢，所以curses库对终端屏幕刷新进行了一些优化处理。
- 在curses库中咱们对标准屏幕的任何更新并不会当即反映到屏幕上，而是必须等咱们调用了函数refresh()或者wrefresh()以后，改变的效果才会在屏幕上真正显示出来。
- 在屏幕刷新的时候curses库系统将标准屏幕与当前屏幕进行比较，而后仅仅刷新物理终端屏幕上的它们之间的不一样之处，一旦进行了刷新，当前屏幕将与标准屏幕相同。

若是咱们对当前屏幕进行更改而尚未调用刷新函数，那么标准屏幕就仅是一个虚拟屏幕。

一旦当前屏幕进行了改动，标准屏幕将发生变化直到下一次刷新。
这种刷新效率最低的时候就是标准屏幕与当前屏幕彻底不一样，不过在大部分状况下都可以加快显示。

4.终端模式

程序使用initscr()进行初始化以后，程序对终端的模式进行了一些设置。终端模式其实是一系列的开关属性，它们直接影响着终端如何处理输入以及输出。例如：

- 当咱们敲入字符的时候，系统将根据模式属性设置来判断字符是否须要当即在屏幕上回显。
  - 系统根据模式设置决定读取字符后的处理方法，是当即一一读取仍是暂时先存放在字符缓冲区中。
  - 系统判断是否须要将输入Ctrl+D解释为文件结束符。
  - 系统判断如何处理功能键F一、F2或者方向键等等，决定是将它们做为普通的键读取仍是做为功能键读取。

（1）ECHO模式（回显模式）

用来决定用户的输入是否当即回显。
- 当ECHO模式设置后，它使得在键盘上输入的每个字符都在终端屏幕上当前光标处显示出来，在调用某些函数如addch()时字符显示后光标的位置将自动的向后移动一个位置。
- 在非回显模式下，字符的显示必须由程序自己来完成，不然字符不会显示。
注：非回显模式下按键一般用来控制屏幕的操做而不是用来进行字符输入!

echo()      设置回显模式
noecho()    关闭回显模式
- 成功返回OK，失败返回ERR。
- 默认状况下回显模式是打开的。

（2）CBREAK模式（当即输入模式）

字符输入在通常的状况下必须加回车键才能完成，这时候退格键是起做用的，输入的字符能够经过BackSpace键删除掉。可是这种操做并不适合交互操做。
- 在CBREAK模式下，除了DELETE或者CTRL等仍然被视为特殊控制字符之外，全部的输入字符都被当即读取出来。
- 若是没有设置CBREAK模式，从键盘输入的字符都将被存储在缓冲区里面直到输入回车键或者行结束符。
注：中断字符和流控制字符并不受这个模式的影响。

int  cbreak()   打开当即输入模式
int  nocbreak() 关闭当即输入模式

默认状况下CBREAK模式是打开的。
在旧版本的curses中，必须使用crmode()和nocrmode()取代cbreak()和nocbreak()。

（3）NEWLINE模式

NEWLINE模式用来决定当输入时回车键是否被对应为新行产生符。

int nl()
int nonl()

默认状况下，NEWLINE模式是打开的。
若是终端设置成NEWLINE模式，那么在输入字符的时候，按下回车键将会产生新的一行，同时在输出字符的时候换行符将对应成回车键。

（4）功能键模式

一般状况下功能键好比左移方向键‘←’是不会被读取转换的，即便调用wgetch()之类的函数也不能将它们读取出来。
为了读取这些特殊键，必须设置功能键模式。
- 一旦功能键模式开启，键盘上的一些按键均可以转换为curses.h内部定义的一些特殊键值。
- 这些键一般以“KEY_”开始。

int  keypad(win，buf)

参数：

WINDOW *win     一个WINDOW类型的指针，它指向须要设置功能键模式的窗口
int buf         buf为TRUE或者FALSE，用来指定模式的开启和关闭。

功能键定义	控制码	描述
KEY_MIN	0401	Curses中定义的最小的键值
KEY_BREAK	0401	Break按键
KEY_DOWN	0402	↓
KEY_UP	0403	↑
KEY_LEFT	0404	←
KEY_RIGHT	0405	→
KEY_HOME	0406	Home键
KEY_BACKSPACE	0407	退格键backspace
KEY_F0	0410	功能键F0
KEY_F(n)	KEY_F0+n	功能键Fn
KEY_DL	0510	行删除键
KEY_IL	0511	行插入键
KEY_DC	0512	字符删除键
KEY_IC	0513	字符插入键
KEY_NPAGE	0522	下一页
KEY_PPAGE	0523	上一页
KEY_END	0550	end按键
KEY_MAX	0777	最大的curses键值

完整的资料能够在文件<tinfo.h>找到，一般它的目录为/usr/include/目录下。

（5）RAW模式（原始模式）

与CBREAK模式相似，用户的输入会当即被接受，可是某些中断字符，转义字符以及挂起和流控制字符将再也不起做用，取而代之的是产生一个相应的信号。
CBREAK模式是覆盖RAW模式的，若是同时设置CBREAK和RAW模式，将仅有RAW模式起做用。

int raw()；
int noraw()；

（6）延迟模式

延迟模式包括半延迟模式和无延迟模式。

半延迟模式下的全部的用户输入都是当即被接受的，可是若是在一段时间内没有用户输入，则输入函数当即返回ERR。这段时间间隔能够本身指定，单位一般为1/10秒，范围为1-255。
无延迟模式主要用来控制终端的字符输入。通常状况下，终端输入函数好比getch()是阻塞调用，即一直等待直到键盘输入才返回。而无延迟模式能够将这种调用更改成非阻塞调用，即一旦getch()发现键盘没有任何输入它就返回错误ERR。

- int halfdelay(tenth)  设置半延迟模式
- nocbreak()            能够取消终端的半延迟模式
- int nodelay(win，bf)   函数设置终端无延迟模式。

参数：

- int tenth指定半延迟的时间间隔，单位是10毫秒。
- WINDOW *win   指向须要设置无延迟模式的窗口的指针
- bool bf   用来决定开启或者关闭该模式。若bf为TRUE，则设置无延迟模式。

5.字符及字符串操做

字符和字符串操做是应用程序中使用频率最高的，curses库中的一些基本函数容许咱们从键盘接受输入，而且将结果输出到指定窗口上或者在指定窗口上读写、删除字符和字符串、定位光标位置或者控制字符色彩等。

（1）字符、字符串输出

addch()函数

int  addch(ch)；
int echochar(ch)；
chtype ch；

- 若是函数执行成功，将返回OK常量，不然返回ERR。

addch()函数是curses中的核心输出函数。将给定的字符输出到标准屏幕上的当前位置。
addch()函数输出后并不执行屏幕刷新，所以为了可以显示输出结果，咱们就必须调用refresh()函数。
echochar()函数能够在完成字符输出的同时完成刷新，在使用非控制字符的时候很是方便。
参数是一个chtype类型的字符，curses中将chtype声明为无符号长整型，它的低位能够包含字符自己的信息，这部分与char字符类型类似，它的高位部分存储了字符的额外的属性信息，好比字符是否高亮度显示，是否反显以及什么色彩等等。
函数在当前光标处输出一个字符，同时光标将向右移动一个位置。若是移动后光标将超出了当前屏幕的范围，光标将自动换行到下一行的开始位置。
除了经常使用的字符参数之外，addch()函数还可使用的C语言中的转义字符：

转义字符	描述
/n	换行，删除当前到行尾的全部字符，并将字符指针向下移动一行。若设newline标志，addch将删除光标后的全部字符并将字符指针置于下行开始处。
/r	回车，将字符指针置于当前行的开始处。
/t	制表符，将字符指针移动到下一个制表符处。

由addch()衍生出来的函数还有waddch()、mvaddch()、mvwaddch()

特殊的行图形字符

一般用来绘图或者制表。curses中的字符实际上就是由它们中的部分组成。对于这些特殊的符号，curses中定义了一些常量与之对应，这些常量都以ACS_开始，一般称之为ACS_常量。

addstr()函数

int   addstr(str)；
char *str；

addch()函数只能在当前位置增长一个字符，若是须要增长字符串，那就须要使用addstr()函数。
字符串的首字符将在当前光标处输出，它的参数是一个字符指针。
若是字符串的长度超出了屏幕的大小，字符串将被截取掉。
curses中与addstr()相似的函数还包括waddstr()、mvwaddstr()、mvaddstr()。

printw()函数

int  printw(fmt [，arg…])
char *fmt；

printw()函数在屏幕上格式化输出一个或者多个值，这些值包括字符串、字符、十进制数、八进制数、以及二进制数。
主要用来在标准屏幕上格式化输出。它与C语言中的printf()相似，也是变参函数，并且用法几乎彻底相同。

参数：

- fmt  是一个字符串指针，用来表示打印的格式，好比对于字符串格式为%s，字符为%c，十进制整数为%d，八进制整数为%o等。
  - arg  是须要打印的值，若是给出的arg不止一个，每个都必须用逗号隔开，它们必须与fmt的格式相适应。
  - 若是fmt为%s格式，则相应的arg参数必须为一个字符串指针，
  - 若是fmt为%d格式，则相应的arg参数必须为整数。

相似的函数有mvprintw()，mvwprintw()，wprintw()。

（2）字符、字符串输入

getch()函数

getch()函数能够从终端键盘读入一个字符，而且返回字符的整数值。这个函数一般用来从键盘接受输入。
输入模式决定了在程序接受字符以前内核进行处理的过程。若是终端被设置成ECHO模式，getch()接受的字符将当即在屏幕上显示，不然屏幕将保持不变化直到刷新后才显示出来

一般状况下，内核会缓存输入文本，若不须要输入缓存，就必须设置CBRREAK或者raw模式。

-  在raw模式下，内核并不进行缓存处理。
 -  在CBREAK模式下，除了^S、^Q、^C、^Y 等控制字符之外，其他的字符都原封不动的发送到系统中被处理。
 -  若是终端没有设置成RAW或者NOECHO模式，getch()将自动的将终端设置成CBREAK模式。

对于普通的字符，getch() 将返回与字符自己相同的整数值。但若是想获取功能键和方向键等咱们则必须设置功能键模式。一旦进行设置，getch()将返回curses.h中定义的与这些功能键对应的整数。

getstr()函数

int  getstr(str)
char* str

从终端键盘接受字符串，而且显示在指定的位置上。
str是一个字符指针指向字符串变量或者存储字符串的位置。从键盘输入时候字符串必须以‘/n’结束，当字符串被存储的时候，‘/n’被空字符所代替。
与getch()相同，若是终端模式被设置为ECHO，getstr()将终端屏幕上当即更新显示字符。若是终端模式没有设置为RAW或者NOECHO模式，函数将自动将终端设置为CBREAK模式，并在读入字符串之后自动恢复到之前的模式。

scanw()函数

int scanw(fmt [，argptr…])
char * fmt；

格式化输入数据，并把它们拷贝到指定的位置，这个值能够是字符串、字符、十进制、八进制或者二进制数。
scanw()与scanf()函数相似，是一个变参函数。

（3）字符插入和删除

int  insch(ch)
chtype ch；
int delch()；

insch()函数能够用来在当前位置上插入一个字符。
字符插入之后光标将自动的向右移动一个位置，若是最右边的字符超出了终端屏幕的范围，它将被截取掉。
delch()删除当前光标处字符的函数。
从当前位置删除一个字符，而且将删除字符右边的全部字符向左移动一个位置。当前行最右边的字符由空格代替。

（4）行插入和删除

int insertln()；
int deleteln()；

deleteln()函数删除当前行，而且将当前行下的全部的行向上移动一行，最后一行则用空格代替。
deleteln()函数没有任何的参数，若是函数执行正确，返回OK，不然返回ERR。

6.字符属性

（1）常见属性列表

A_NORMAL：标准的显示模式
A_BLINK：闪烁属性
A_BOLD：加粗属性
A_DIM： 半透明属性
A_REVERSE：反显属性
A_STANDOUT：高亮度显示属性
A_UNDERLINE：加下划线
A_ALTCHARSET：可代替字符集
COLOR_PAIR(n)：字符的背景和前景属性

（2）设置和取消字符属性

int  attron(attrs)
int  attrset(attrs)
int attroff(attrs)
- chtype attrs；

前面列出的那些属性能够单独的设置和关闭，某个属性的设置和关闭对其他的属性不会产生任何影响。
attron()设置attrs参数指定的属性，它的设置不影响任何如今已经存在的属性，可是一旦它设置，以后输出的全部的文本字符都将受该属性的影响。
attrset()的设置将影响到当前的全部的属性，由于它是用attrs指定的参数属性代替当前的全部属性，若是某个属性在设置以前是打开的，在attrs中却没有设置，那么设置后这个属性将被关闭。
attroff()关闭某个已经存在的属性。
attrset(0)的特殊用法关闭全部的属性。

7.光标操做

（1）光标的概念

Curses库中光标分为物理光标和逻辑光标。
- 物理光标是最经常使用的光标，每一个窗体只有一个物理光标。
- 逻辑光标属于curses窗体，每一个窗体可能有多个逻辑光标。

在窗体（包括标准屏幕stdscr）中进行输入输出的时候，逻辑光标会不断的定位于窗体中要进行操做的区域。所以经过移动逻辑光标，能够在任什么时候候在窗体的任何部分进行输入输出。

int move(y，x)；
int y，x；

move()函数能够将逻辑光标移动到给定的位置。
这个位置是相对与屏幕的左上角而言，左上角的坐标为(0，0)。
参数y是移动后位置的所在的行数，x为新位置所在的的列数。若是移动的目标位置超出了屏幕的范围，则会致使错误。
屏幕的行宽和列宽在curses库中定义为(LINES-1，COLS-1)。
须要注意的是行和列都是从0开始计数。咱们进行的大部分操做在操做以前都须要移动光标到必定的位置，若是这样的话咱们须要分两步进行：移动光标，而后进行相关操做。为了更方便，一些函数将移动光标与显示字符结合起来执行。这种函数的格式通常以下：
```
mvfunc(y ， x， [arg，…])

  - func通常为操做函数的名字，好比addch，addstr等等。
  - y为操做进行时候光标所在的行数，一般也是移动以后的新的光标位置。
  - x为操做进行时候光标所在的列数。
```
例如：须要将光标移动到(10，5)处而后输出字符‘X’，那么咱们就可使用move()函数与addch()函数结合造成的mvaddch()函数来实现。能够写为:mvaddch(10，5，‘X’)；

（2）清除屏幕

清除整个屏幕

方法一：先用空白字符填充屏幕全部区域，而后再调用refresh()函数刷新屏幕。
方法二：是用固定的终端控制字符清除屏幕。
第一种方法比较慢，由于它须要重写当前屏幕。第二种能迅速清除整个屏幕内容。

- 清除整个屏幕
    int clear()；
    int erase()；
- 清除指定窗口
    wclear()；
    werase()；

这四个函数在标准屏幕上使用空格来代替当前字母从而达到清屏的效果。
clear()清除屏幕上的全部的字符而且将光标移动到屏幕的原点(0，0)，继而自动调用clearok()函数，这使得屏幕在下次调用refresh()刷新的时候可以彻底被清除。所以clear()函数可以清除物理屏幕上的那些没法识别的东西，这样下次输出将是基于一个彻底“干净”的屏幕进行的。
erase()函数一样能够用来清除屏幕，可是它不会自动调用clearok()函数，所以与clear()相比，它并非一种最完全的清除方式。

部分屏幕清除

int  clrtoeol()
int  clrtobot()

用空格代替当前的须要清除部分的现有字符。
clrtobot()清除从当前光标位置到屏幕底端的全部内容。
clrtoeol()清除屏幕上从当前光标位置到该行末尾的全部字符。
必须调用refresh()之后才开始生效。
无论clrtobot()仍是clrtoeol()都会改变当前光标的位置。

以上只是我编写TUI游戏中用到的curses中的最简单、最基础的内容，个人代码中对于颜色、窗体都没有设计编写，实现的很是简单...

2、事件驱动编程：编写一个视频游戏

1.视频游戏和操做系统

（1）视频游戏怎么作

建立游戏中物体的影像，并使它们移动。
- 每一个程序建立的东西都有本身的属性：移动速度、方向、动力和其它属性。
- 物体之间相互联系，做用。
游戏要与用户互动，响应用户输入。
- 游戏玩家经过按钮和鼠标，在任什么时候刻都有可能生成输入，程序必须在短期内作出响应。
- 这些输入会影响建立的物体的属性，改变移动速度、方向等。

（2）视频游戏如何作

空间

游戏必须在计算机屏幕的特色位置画影像。
程序如何控制视频显示？

时间

影像在屏幕上移动，以一个特定的时间间隔改变位置。
程序如何获知时间而且在特定的时间触发事情发生呢？

中断

程序在屏幕上平滑的移动物体，用户能够在任意时刻产生输入。
程序是如何响应这些中断的？

并发——同时作几件事

游戏在保证几个影像移动的同时还要响应中断。
程序如何实现同时作这么多事而不被弄得晕头转向呢？

（3）类比操做系统面临相似问题

操做系统一样要面临上面4个相似的问题：

- 内核将程序载入内存空间并维护每一个程序在内存中所处的位置。
  - 在内核的调度下，程序以时间片间隔的方式运行，同时，内核在特定的时间运行特定的任务。
  - 内核必须在很短的时间内响应用户和外设在任什么时候刻的输入。
  - 同时，作几件事须要一些技巧。内核要保证数据的有序和规整的。

屏幕管理、时间、信号、共享资源

（4）弹球游戏

三个主要元素：墙、球和挡板

游戏的概要描述：

- 球以必定的速度和方向移动
  - 球碰到墙壁或挡板会被弹回
  - 用户按按钮来控制挡板移动

2.时间与时钟

（1）sleep

需求：游戏中，须要把影像在特定的时间置于特定的位置。用curses把影像置于特定的位置，而后在程序中添加时间响应。
方法：使用系统函数sleep。

简单的例子1

#include    <stdio.h>
#include    <curses.h>

void main()
{
    int i;
    initscr();
       clear();
       for(i=0; i<LINES; i++ ){
        move( i, i+i );
        if ( i%2 == 1 ) 
            standout();
        addstr("Hello, world");
        if ( i%2 == 1 ) 
            standend();
        sleep(1);
        refresh();  //比较不一样，而后刷新屏幕
       }
    endwin();
}

Hello，world这串字符在屏幕上自上而下逐行显示，每秒增长一行，反色和正常交替出现。

简单的例子2

如何让上一个例子创造移动的假象？

#include    <stdio.h>
  #include    <curses.h>

  void main()
  {
      int i;

      initscr();
         clear();
         for(i=0; i<LINES; i++ ){
          move( i, i+i );
          if ( i%2 == 1 ) 
              standout();
          addstr("Hello, world");
          if ( i%2 == 1 ) 
              standend();
          refresh();
          sleep(1);
          move(i,i+i);    //将光标移动到上一条字符串的开头
          addstr("             ");    //用空串覆盖原有字符串
         }
      endwin();
  }

方法：先输出一个字符串，而后sleep一秒，而后在原来的地方写空字符串覆盖掉原有字符串，在下一行输出新的字符串。

sleep如何工做的:使用Unix中的Alarms

sleep函数由3个步骤组成:

- 为SIGALRM设置一个处理函数
  - 调用alarm(num_seconds)
  - 调用pause

存在的问题

一秒钟的时间太长，须要更精准的计时器
须要增长用户输入

（2）间隔计时器

- 有更高的精度：能够精确到微秒。
    - usleep()将当前进程挂起n微秒或者直到有一个不能被忽略的信号到达。
- 每一个进程都有3个独立的计时器
- 每一个计时器有两个设置:初始间隔和重复间隔设置
- 支持alarm和sleep

三种计时器

- 真实（ITIMER_REAL）：进程运行的所有时间
- 虚拟（ITIMER_VIRTUAL）：进程在用户态的时间
- 实用（ITIMER_PROF）：进程在用户态加内核态的时间

两种间隔

包含初始间隔和重复间隔，每一个间隔由秒数和微秒数组成。
```
- 初始间隔  it_value
  - 重复间隔  it_interval
```
it_value设为0，关掉两个时钟。
it_interval设为0，再也不重复这一特征。

取得或设置间隔计时器

#include<sys/time.h>

int set_ticker(int n_msecs)  
{  
    struct itimerval new_timeset;  
    long n_sec, n_usecs;  

    n_sec = n_msecs / 1000;  
    n_usecs = (n_msecs % 1000) * 1000L;  

    new_timeset.it_interval.tv_sec = n_sec;  //设置初始间隔  
    new_timeset.it_interval.tv_usec = n_usecs;  

    new_timeset.it_value.tv_sec = n_sec;   //设置重复间隔  
    new_timeset.it_value.tv_usec = n_usecs; 

    return setitimer(ITIMER_REAL, &new_timeset, NULL);     
}

- getitimer(int which, struct itimerval *val)  
- setitimer(int which, const struct itimerval* newval, struct itimerval *oldval);  
- which指定哪一种计时器：ITMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF。

struct itimerval

struct itimerval {
    struct timeval it_interval;
    struct timeval it_value;
};
struct timeval {
    time_t tv_sec;
    suseconds_t tv_usec;
};

小结

内核只有一个系统时钟脉冲，当收到一个时钟脉冲，内核将会使全部的计时器减一个时钟单位。即内核在每一个时钟脉冲时，遍历全部的间隔计时器，使用这样的手段来管理每一个进程的真实计时器。
其余两个计时器，在程序运行的特定时刻进行计时。
经过这样的机制，来实现每一个进程三个计时器的管理。
能够经过setitimer系统调用，获得了更高的精度控制计时器，同时可以以固定的时间间隔发送信号

3.信号处理

（这一部分在《深刻理解计算机系统》第八章中已经学习过，就再也不赘述）

3、弹球游戏的实现与优化

1.基本弹球功能实现

（1）头文件

#include <curses.h>
#include <sys/time.h>
#include <signal.h>
#include <stdlib.h>

（2）宏定义

#define LEFT 0      //当前屏幕的最左边
#define TOP 0       //当前屏幕的最上边
#define RIGHT COLS-1    //球所能到达的当前屏幕最大水平范围
#define BOTTOM LINES-1  //球所能到达的当前屏幕最大垂直范围
#define WIDE RIGHT-LEFT+1   //宽度
#define BOARD_LENGTH 10     //挡板长度

（3）全局变量

char BALL = 'O';    //球的形状
char BLANK = ' ';   //覆盖球走过的轨迹

int hdir;   //控制球水平运动的变量
int vdir;   //控制球垂直运动的变量
int pos_X;  //球的横坐标
int pos_Y;  //球的纵坐标

int left_board;     //挡板左端点
int right_board;    //挡板右端点
int is_lose=0;      //标志：小球是否落在挡板上

int delay=100;  //设置速度
int ndelay;     //速度倍数

（4）主函数

int main()
{

    //初始化curses
    initscr();
    crmode();   //中断模式
    noecho();   //关闭回显
    control();
    endwin();   //结束 curses
    return 0;
}

（5）初始化小球和挡板

void init()
{
    int i,j;
    clear();

    //初始球
    pos_X =20;      //球初始的横坐标
    pos_Y = BOTTOM-1;   //球初始的纵坐标

    //初始化球的运动方向,朝右上方运动
    hdir=1;
    vdir=-1;

    //初始挡板
    left_board=20;
    right_board=left_board+BOARD_LENGTH;
    //显示挡板
    for(i=left_board;i<=right_board;i++)
    {
        move(BOTTOM,i);
        addch('=');
    }

    //初始刷新时间
    ndelay=2;
    signal(SIGALRM,moveBall);
    set_ticker(delay*ndelay);

    keypad(stdscr,TRUE);    //打开 keypad 键盘响应
    attroff(A_BLINK);   //关闭 A_BLINK 属性
    
    is_lose=0;
    move(pos_Y,pos_X);
    addch(BALL);
    move(LINES-1, COLS-1);
    refresh();
    usleep(100000);
    move(LINES-1,COLS-1);
    refresh();
}

特别注意：屏幕的坐标原点在左上角，向上运动是负数。

（6）小球运动

void moveBall()
{
    if(is_lose) return;
    signal(SIGALRM,moveBall);
    move(pos_Y,pos_X);
    addch(BLANK);
    pos_X += hdir;
    pos_Y += vdir;

    //改变方向
    if(pos_X >= RIGHT)  //当球横坐标大于右边边缘时，球反弹朝左运动
        hdir = -1;
    if(pos_X <= LEFT)   //当球横坐标大于左边边缘时，球反弹朝右运动
        hdir = 1;
    if(pos_Y <= TOP)    //当球纵坐标大于顶部边缘时，球反弹朝下运动
        vdir = 1;

    //当球在底部的时候进行额外的处理
    if(pos_Y >= BOTTOM-1)
    {
        if(pos_X>=left_board&&pos_X<=right_board)   //球在挡板处
            vdir=-1;
        else    //球不在挡板处
        {
            is_lose=1;
            move(pos_Y,pos_X);
            addch(BALL);
            move(LINES-1, COLS-1);
            refresh();
            usleep(delay*ndelay*1000);
            move(pos_Y,pos_X);
            addch(BLANK);
            pos_X += hdir;
            pos_Y += vdir;
            move(pos_Y,pos_X);
            addch(BALL);
            move(LINES-1, COLS-1);
            refresh();
        }
    }
    //不改变球的方向
    move(pos_Y,pos_X);
    addch(BALL);
    move(LINES-1, COLS-1);
    refresh();
    
}

(7)键盘控制事件响应

cmd=getch();
    if(cmd=='q') break;//按“Q”键退出游戏
    //挡板左移
    else if(cmd==KEY_LEFT)
    {
        if(left_board>0)
        {
            move(BOTTOM,right_board);
            addch(' ');
            right_board--;
            left_board--;
            move(BOTTOM,left_board);
            addch('=');
            move(BOTTOM,RIGHT);
            refresh();
        }
    }   
    //挡板右移
    else if(cmd==KEY_RIGHT)
    {
        if(right_board<RIGHT)
        {
            move(BOTTOM,left_board);
            addch(' ');
            right_board++;
            left_board++;
            move(BOTTOM,right_board);
            addch('=');
            move(BOTTOM,RIGHT);
            refresh();
        }
    }

(8)输掉球后的处理

int flag=1;
char choice;
move(6,10);
addstr("Game over! Do you want try again?(y/n):");
refresh();
choice=getch();
while(flag)
{
    if(choice=='y'||choice=='Y'||choice=='n'||choice=='N')
        flag=0;
    else  choice=getch();
}
if(choice=='y'||choice=='Y')
{
    init();
    continue;
}
else
{
    if(choice=='n'||choice=='N')
        break;
}

（8）计时器用的就是以前提到的间隔计数器：int set_ticker(int n_msecs)

2.优化与改进

增长欢迎界面

设置游戏难易程度：更改小球速度和挡板长度

增长计分功能

附：最终版源代码

/*
    Bounceball Game
    Version 1.3
        - 新增welcome界面
        - 可设置游戏难易程度（小球速度,挡板长度）
        - 记分
*/
#include <curses.h>
#include <sys/time.h>
#include <signal.h>
#include <stdlib.h>

#define LEFT 0      //当前屏幕的最左边
#define TOP 0       //当前屏幕的最上边
#define RIGHT COLS-1    //球所能到达的当前屏幕最大水平范围
#define BOTTOM LINES-1  //球所能到达的当前屏幕最大垂直范围
#define WIDE RIGHT-LEFT+1   //宽度

char BALL = 'O';    //球的形状
char BLANK = ' ';   //覆盖球走过的轨迹

int hdir;   //控制球水平运动的变量
int vdir;   //控制球垂直运动的变量
int pos_X;  //球的横坐标
int pos_Y;  //球的纵坐标

int left_board;
int right_board;
int BOARD_LENGTH;   

int is_lose=0;
int score=0;

int delay;
int ndelay;
void init();
void moveBall();
void control();
int set_ticker(int n_msecs);
void start();
void help();
void information();
int welcome();

int main()
{

    //初始化curses
    initscr();
    crmode();   //中断模式
    noecho();   //关闭回显

    welcome();

    endwin();   //结束 curses
    return 0;
}

int welcome()
{
    move(6,20);
    addstr("Hello! Welcome the the Bounceball Game!");
    move(8,23);
    addstr("1.Start the Game");
    move(9,23);
    addstr("2.Help");
    move(10,23);
    addstr("3.About me");
    move(11,23);
    addstr("4.Quit");

    int flag = 1;
    char choice;    
    move(13,23);
    addstr("Please choose your choices : ");
    refresh();
    choice=getch();
    while(flag)
    {
        if(choice=='1'||choice=='2'||choice=='3'||choice=='4')
        {
            flag = 0;
            switch(choice)
            {
                case '1':
                    start();
                    break;
                case '2':
                    help();
                    welcome();
                    break;
                case '3':
                    information();
                    welcome();
                    break;
                case '4':
                    break;
            }
        }
        else
            choice=getch();
    }
    return 0;
}

void start()
{
    clear();
    move(6,20);     
    addstr("Game Level:");
    move(8,23);
    addstr("1.Easy");
    move(9,23);
    addstr("2.Normal");
    move(10,23);
    addstr("3.Hard");

    score=0;
    int flag = 1;
    char choice;    
    move(13,23);
    addstr("Please choose the level : ");
    refresh();
    choice=getch();
    while(flag)
    {
        if(choice=='1'||choice=='2'||choice=='3')
        {
            flag = 0;
            switch(choice)
            {
                case '1':
                    delay=100;
                    BOARD_LENGTH=10;
                    break;
                case '2':
                    delay=60;
                    BOARD_LENGTH=8;
                    break;
                case '3':
                    BOARD_LENGTH=5;
                    delay=40;
                    break;
            }
        }
        else
            choice=getch();
    }

    clear();
    move(8,20);     
    addstr("Are you ready?");
    refresh();
    control();
}

void control()
{
    init();
    int cmd;
    while (1)
    {   
        if(!is_lose)
        {
            cmd=getch();
            if(cmd==27) break;//退出
            //挡板左移
            else 
            {
                if(cmd==KEY_LEFT)
                {
                    if(left_board>0)
                    {
                        move(BOTTOM,right_board);
                        addch(' ');
                        right_board--;
                        left_board--;
                        move(BOTTOM,left_board);
                        addch('=');
                        move(BOTTOM,RIGHT);
                        refresh();
                    }
                }
                //挡板右移
                else 
                {
                    if(cmd==KEY_RIGHT)
                    {
                        if(right_board<RIGHT)
                        {
                            move(BOTTOM,left_board);
                            addch(' ');
                            right_board++;
                            left_board++;
                            move(BOTTOM,right_board);
                            addch('=');
                            move(BOTTOM,RIGHT);
                            refresh();
                        }
                    }
                }
            }   
        }
        else
        {
            //输掉球后的处理
            int flag=1;
            char choice;
            move(6,20);
            addstr("Game over!");
            move(8,20);
            addstr("Your score : ");
            printw("%d",score);
            move(10,20);
            addstr("Do you want to try again?(y/n):");
            refresh();
            choice=getch();

            while(flag)
            {
                if(choice=='y'||choice=='Y'||choice=='n'||choice=='N')
                    flag=0;
                else  choice=getch();
            }
            if(choice=='y'||choice=='Y')
            {
                score=0;
                init();
                continue;
            }
            else
            {
                if(choice=='n'||choice=='N')
                {
                    clear();
                    refresh();
                    welcome();
                    break;
                }
            }   
        }
    }
}

void init()
{
    int i,j;
    clear();

    //初始球
    pos_X =20;      //球初始的横坐标
    pos_Y = BOTTOM-1;   //球初始的纵坐标

    //初始化球的运动方向,朝右上方运动  
    hdir=1;
    vdir=-1;

    //初始挡板
    left_board=20;
    right_board=left_board+BOARD_LENGTH;

    //显示挡板
    for(i=left_board;i<=right_board;i++)
    {
        move(BOTTOM,i);
        addch('=');
    }

    //初始刷新时间
    ndelay=2;
    signal(SIGALRM,moveBall);
    set_ticker(delay*ndelay);

    keypad(stdscr,TRUE);    //打开 keypad 键盘响应
    attroff(A_BLINK);   //关闭 A_BLINK 属性

    is_lose=0;
    move(pos_Y,pos_X);
    addch(BALL);
    move(LINES-1, COLS-1);
    refresh();
    usleep(100000);
    move(LINES-1,COLS-1);
    refresh();
}

void moveBall()
{
    if(is_lose) return;
    signal(SIGALRM,moveBall);
    move(pos_Y,pos_X);
    addch(BLANK);
    pos_X += hdir;
    pos_Y += vdir;

    //改变方向
    if(pos_X >= RIGHT)
        hdir = -1;
    if(pos_X <= LEFT)
        hdir = 1;
    if(pos_Y <= TOP)
        vdir = 1;

    //当球在底部的时候进行额外的处理
    if(pos_Y >= BOTTOM-1){
        if(pos_X>=left_board&&pos_X<=right_board)
        {
            vdir=-1;
            score++;
        }
        else
        {
                is_lose=1;
                move(pos_Y,pos_X);
                addch(BALL);
                move(LINES-1, COLS-1);
                refresh();
                usleep(delay*ndelay*1000);
                move(pos_Y,pos_X);
                addch(BLANK);
                pos_X += hdir;
                pos_Y += vdir;
                move(pos_Y,pos_X);
                addch(BALL);
                move(LINES-1, COLS-1);
                refresh();
        }
    }
    //不改变球的方向
    move(pos_Y,pos_X);
    addch(BALL);
    move(LINES-1, COLS-1);
    refresh();
    
}

int set_ticker(int n_msecs)
{
    struct itimerval new_timeset;   
    long n_sec,n_usecs;
    n_sec=n_msecs/1000;
    n_usecs=(n_msecs%1000)*1000L;
    new_timeset.it_interval.tv_sec=n_sec;
    new_timeset.it_interval.tv_usec=n_usecs;
    new_timeset.it_value.tv_sec=n_sec;
    new_timeset.it_value.tv_usec=n_usecs;
    return setitimer(ITIMER_REAL,&new_timeset,NULL);
}


void help()
{
    clear();
    move(6,20);
    addstr("Help Information");
    move(8,23);
    addstr(" <- : Control the baffle left shift");
    move(9,23);
    addstr(" -> : Control the baffle right shift");
    move(10,23);
    addstr(" q : Exit the game ");
    move(12,40);
    addstr("Press any key to exit...");
    refresh();
    int ch=getch();
    clear();
    refresh();
}

void information()
{
    clear();
    move(6,20);
    addstr("About the Game");
    move(8,23);
    addstr("written by 20135317_Han");
    move(9,23);
    addstr("Version 1.3");
    move(11,40);
    addstr("Press any key to exit...");
    refresh();
    int ch=getch();
    clear();
    refresh();
}

4、简单TUI游戏设计实践总结

1.关于curses库

这个弹球游戏的设计实践实现的很是简单，老师给的参考资料中的《Unix/Linux下的Curses库开发指南》对Curses库的讲解很是全面，并且有代码的例子供读者参考，易于理解。
个人代码中用到的主要是这本书前两章的内容，没有对颜色、窗口、鼠标、面板、菜单、表单的设置，可是看了书中的介绍，让我感到curses库的真的是很强大，尤为是它良好的可移植性和简单的操做函数应用让编写变得容易了许多。

2.在编程任务中学习

另外一本参考资料《Unix-Linux编程实践教程》给我提供了很好的在编程任务中学习的例子。这本书的组织模式就是经过读者的编写来学习相关内容。好比经过编写who命令学习用户、文件和联机帮助，经过编写ls命令学习目录与文件属性......这个视频游戏也是经过编写一个弹球游戏来学习curses库、时间和时钟编程、信号处理的内容。
这学期有一次实践中我本身尝试编写了who命令，对这种在编程任务中学习的方法感觉很深。这样的学习方式会花费了很多时间，由于编写的过程当中不可避免的会遇到的不少问题，可是经过查找资料和本身的认真分析研究去解决以后，对问题的理解会更深刻，也颇有成就感。

3.其它

此次实践编写不是很难，可是这篇博客因为各类缘由拖了很长时间才完成。我本身感受写完就像从头又学习了一遍，却是对一些以前理解模糊的概念更清楚了。
越学越以为本身不会的好东西太多了，老师给的这两本参考资料，尤为是《Unix/Linux编程实践教程》，感受对学习教材《深刻理解计算机系统》是很是好的辅助。多是由于有些东西是从不一样角度的讲解，相辅相成，理解得更加深刻。

参考资料

参考资料1：Unix/Linux编程实践教程(Understanding UNIX/LINUX Programming)
参考资料2：Unix/Linux下的Curses库开发指南——第一章 Curses库开发简介
参考资料3：Unix/Linux下的Curses库开发指南——第二章 curses库I/O处理
参考资料4：Linux下curses函数库安装运行
参考资料5：linux中curses使用
参考资料6：curses编程函数1（三类输出函数）
参考资料7：Linux的sleep()和usleep()的使用
参考资料8：《Unix-Linux编程实践教程》读书笔记（七）
参考资料9：第七章事件驱动编程(curses库，计时器，信号，异步I/O)
参考资料10：Linux进程的计时器和间隔计时器
参考资料11：时钟编程: alarm和setitimer
参考资料12：信息安全系统设计基础第十周学习总结——第八章异常控制流