The sample of O_ASYNC and aio_read

O_ASYNC 和 aio_read 示例代码, 主要用来示范Linux中的信号量.

代码为一个游戏,用*去捕捉小球,
Q --退出
S,s,F,f --加快或减缓小球x或y方向移动速度
z,x--改变小球x或y轴移动方向
i,j,k,l 移动*号.

bounce.h:




/**//* bounce.h


* somet settings for the game


*/


#ifndef bounce_h


#define bounce_h




#include <aio.h>


#include <curses.h>


#include <fcntl.h>


#include <string.h>


#include <unistd.h>




#define BLANK ' '


#define DFL_SYMBOL 'o'


#define PL_SYMBOL '*'


#define TOP_ROW 5


#define BOT_ROW 20


#define LEFT_EDGE 10


#define RIGHT_EDGE 70


#define X_INIT 10 // starting col


#define Y_INIT 10 // starting row


#define TICKS_PER_SEC 50 // affects speed


#define X_TTM 8


#define Y_TTM 8




int done = 0;


int score = 0;




// the ping pong ball




struct ppball...{


int y_pos,x_pos,


y_ttm,x_ttm,


y_ttg,x_ttg,


y_dir,x_dir;


char symbol;


};




// the player




struct player ...{


int y_pos,x_pos;


char symbol;


};




struct aiocb kbcbuf;


struct ppball the_ball;


struct player the_player;




int set_ticker(int);


void draw_wall();


void draw_score();


void draw_player();


void move_player(char);


#endif



bounce2d.c:




/**//* bounce2d 1.0


* bounce a character (defaults is 'o') around the screen


* defined by some paraments


*


* user input:


* s slow down x component, S: slow y component


* f speed up x component, F: speed y component


* Q quit


*


* purpose animation with use control, using aio_read() or O_ASYNC


* timer tick sends SIGALRM, handler does animation


* keybords sends SIGIO


* main only class pause()


* build: cc bounce2d.c set_ticker.c -lcurses -l rt-o bounce2d


*/


#include "bounce.h"






// the main loop




void set_up();


void wrap_up();






int main() ...{


set_up();




while(!done) // the main loop


pause();




wrap_up();




return 0;


}






/**//*


* init structure and other stuff


*/




void set_up() ...{


void ball_move(int);


void enable_kdb_signals();


void setup_aio_buffer();


void on_input(int);




// setup the ball's state


the_ball.y_pos = Y_INIT;


the_ball.x_pos = X_INIT;


the_ball.y_ttg = the_ball.y_ttm = Y_TTM;


the_ball.x_ttg = the_ball.x_ttm = X_TTM;


the_ball.y_dir = 1;


the_ball.x_dir = 1;


the_ball.symbol = DFL_SYMBOL;




done = 0;




initscr(); // setup the screen


noecho();


crmode();


clear();




// setup the player's state and draw the player


the_player.x_pos = LEFT_EDGE;


the_player.y_pos = TOP_ROW;


the_player.symbol = PL_SYMBOL;


draw_player();




// draw the wall


draw_wall();




// setup and draw the score


score = 0;


draw_score();




signal(SIGINT,SIG_IGN);


mvaddch(the_ball.y_pos,the_ball.x_pos,the_ball.symbol);


refresh();




signal(SIGIO,on_input); // install a handler




// use O_ASYNC


// enable_kdb_signals(); // turn on kbd signals




// use aio_read


setup_aio_buffer(); // initialize aio ctrl buff


aio_read(&kbcbuf); // place a read quest




signal(SIGALRM,ball_move); // install alarm handler


set_ticker(1000/TICKS_PER_SEC); // send millisecs per tick


}






void wrap_up() ...{


set_ticker(0);


endwin(); // put back normal


}






void ball_move(int signum) ...{


int y_cur,x_cur,moved;




int bounce_or_lose(struct ppball *);




signal(SIGALRM,ball_move); // don't get caught now


y_cur = the_ball.y_pos; // old spot


x_cur = the_ball.x_pos;


moved = 0;






if(the_ball.y_ttm > 0 && --the_ball.y_ttg == 0) ...{


the_ball.y_pos += the_ball.y_dir; // move


the_ball.y_ttg = the_ball.y_ttm; // reset


moved = 1;


}






if(the_ball.x_ttm > 0 && --the_ball.x_ttg == 0) ...{


the_ball.x_pos += the_ball.x_dir; // move


the_ball.x_ttg = the_ball.x_ttm; // reset


moved = 1;


}






if(moved) ...{


mvaddch(y_cur,x_cur,BLANK);


// mvaddch(y_cur,x_cur,BLANK);


mvaddch(the_ball.y_pos,the_ball.x_pos,the_ball.symbol);




if(bounce_or_lose(&the_ball)) ...{


++score;


draw_score();


draw_wall();


}


move(LINES - 1,COLS - 1);


refresh();


}


signal(SIGALRM,ball_move); // for unreliable systems


}






int bounce_or_lose(struct ppball *bp) ...{


int return_val = 0;






if(bp -> y_pos <= TOP_ROW) ...{


bp -> y_dir = 1;




} else if(bp -> y_pos >= BOT_ROW) ...{


bp -> y_dir = -1;


}






if(bp -> x_pos <= LEFT_EDGE) ...{


bp -> x_dir = 1;




} else if(bp -> x_pos >= RIGHT_EDGE) ...{


bp -> x_dir = -1;


}




if(bp -> x_pos == the_player.x_pos


&& bp -> y_pos == the_player.y_pos)


return_val = 1;




return return_val;


}






/**//*


* intstall a handler, tell kernel who to notify on input, enable signals


*/




void enable_kdb_signals() ...{


int fd_flags;




fcntl(0,F_SETOWN,getpid());


fd_flags = fcntl(0,F_GETFL);


fcntl(0,F_SETFL,(fd_flags | O_ASYNC));


}






/**//*


* handler called to when aio_read() has stuff to read


* First check for any errors codes, and if ok, then get the return code


*/




void on_input(int signum) ...{


int c;






while((c = getchar()) != 'Q') ...{


if(c == 'f') --the_ball.x_ttm;


else if(c == 's') ++the_ball.x_ttm;


else if(c == 'F') --the_ball.y_ttm;


else if(c == 'S') ++the_ball.y_ttm;


else if(c == 'z')


the_ball.x_dir = -the_ball.x_dir;


else if(c == 'x')


the_ball.y_dir = -the_ball.y_dir;


else if(c == 'i' || c == 'j' || c == 'k' || c == 'l')


move_player(c);


}




done = 1;


}






/**//*


* set memebers of struct


* First specify args like those for read(fd,buf,num) and offset


* Then specify what to do(send signal) and what signal(SIGIO)


*/




void setup_aio_buffer() ...{


static char input[1]; // 1 char of input




// describe what to read


kbcbuf.aio_fildes = 0; // standard input


kbcbuf.aio_buf = input; // buffer


kbcbuf.aio_nbytes = 1; // number to read


kbcbuf.aio_offset = 0; // offset in file




// describe what to do when read is ready


kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;


kbcbuf.aio_sigevent.sigev_signo = SIGIO; // send SIGIO


}






/**//*


* draw the wall when setup.


*/




void draw_wall() ...{


int i,j;




// draw four corner


mvaddch(TOP_ROW - 1,LEFT_EDGE - 1,'+');


mvaddch(BOT_ROW + 1,LEFT_EDGE - 1,'+');


mvaddch(TOP_ROW - 1,RIGHT_EDGE + 1,'+');


mvaddch(BOT_ROW + 1,RIGHT_EDGE + 1,'+');




// draw top row




for(i = LEFT_EDGE,j = TOP_ROW - 1; i <= RIGHT_EDGE; ++i) ...{


mvaddch(j,i,'-');


}




// draw left column




for(i = LEFT_EDGE - 1,j = TOP_ROW; j <= BOT_ROW; ++j) ...{


mvaddch(j,i,'|');


}




// draw botton row




for(i = LEFT_EDGE,j = BOT_ROW + 1; i <= RIGHT_EDGE; ++i) ...{


mvaddch(j,i,'-');


}




// draw right column




for(i = RIGHT_EDGE + 1,j = TOP_ROW; j <= BOT_ROW; ++j) ...{


mvaddch(j,i,'|');


}


}






/**//*


* draw score on the left top corner


*/




void draw_score() ...{


char score_string[100];


sprintf(score_string,"score:%d",score);


move(1,1);


addstr(score_string);


}






/**//*


* draw the player


*/




void draw_player() ...{


mvaddch(the_player.y_pos,the_player.x_pos,the_player.symbol);


}






/**//*


* move the player


*/




void move_player(char input) ...{


mvaddch(the_player.y_pos,the_player.x_pos,BLANK);




switch(input) ...{


case 'i':


if(the_player.y_pos > TOP_ROW)


--the_player.y_pos;


break;


case 'k':


if(the_player.y_pos < BOT_ROW)


++the_player.y_pos;


break;


case 'j':


if(the_player.x_pos > LEFT_EDGE)


--the_player.x_pos;


break;


case 'l':


if(the_player.x_pos < RIGHT_EDGE)


++the_player.x_pos;


break;


}


draw_player();


}



set_ticker.c:


#include <stdio.h>


#include <sys/time.h>


#include <signal.h>






/**//*


* set_ticker.c


* set_ticker( number_of_milliseconds )


* arranges for the interval timer to issue


* SIGALRM's at regular intervals


* returns -1 on error, 0 for ok


*


* arg in milliseconds, converted into micro seoncds


*/






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; /**//* set reload */




new_timeset.it_interval.tv_usec = n_usecs; /**//* new ticker value */




new_timeset.it_value.tv_sec = n_sec ; /**//* store this */




new_timeset.it_value.tv_usec = n_usecs ; /**//* and this */




return setitimer(ITIMER_REAL, &new_timeset, NULL);


}







makefile:


bounce2d: bounce2d.c bounce.h set_ticker.c


gcc $^ -l curses -l rt -o $@ -Wall