Linux---弹球游戏

ReadMe：

弹球游戏按键说明(注意大小写)：

Q End Up Game 游戏停止
P Play Again  再玩一次

f 速度x轴方向减速
s 速度x轴方向加速
F 速度y轴方向减速
S 速度y轴方向加速

J 移动挡板变短
L 移动挡板变长

4 移动挡板向左移动
6 移动挡板向右移动

补充说明：
游戏屏幕左上角显示当前得分和游戏状态（ GameOn or GameOver ）
游戏过程中忽略ctrl+c和ctrl+\信号，游戏结束后恢复信号

/×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××/

　　　　分。。。。割。。。。线

/×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××/

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #include <curses.h>

 #include <signal.h>

 #include "bounce.h"

 #include <sys/time.h>

 bool set_up( bool );

 void wrap_up();

 void ball_move();

 void show_baffle();

 void in_bound( struct BallInfo * );

 int set_ticker( int );

 bool judge_in_bound( int ,int );

 void show_baffle();

 void try_move_my_moving_baffle( char );

 void show_my_moving_baffle();

 void cover_my_moving_baffle();

 void show_score_gameon();

 void show_score_gameoff();

 void clear_up();

 void solve_sigint();

 void solve_sigquit();

 bool ball_crash_brick();

 void show_my_moving_brick( int ,int );

 void cover_my_moving_brick( int ,int );

 struct BallInfo my_moving_ball;

 struct BaffleInfo my_moving_Baffle;

 struct Brick my_moving_brick[];

 int score;

 void clear_up(){

        int i,j;

        for( i=;i<;i++ ){

               for( j=;j<;j++ ){

                      mvaddch( i,j,BLANK );

               }

        }

        return ;

 }

 /********************************************************

        clear up the whole screen

 *********************************************************/

 bool set_up( bool flag ){

        char od;

        my_moving_ball.x_pos = startX;

        my_moving_ball.y_pos = startY;

        my_moving_ball.x_Time1 = my_moving_ball.x_Time2 = X_Time;

        my_moving_ball.y_Time1 = my_moving_ball.y_Time2 = Y_Time;

        my_moving_ball.x_dir = ;

        my_moving_ball.y_dir = ;

        my_moving_ball.ball_symbol = BALL;

        my_moving_Baffle.len = BaffleLen;

        my_moving_Baffle.baffle_symbol = BaffleSymbol;

        my_moving_Baffle.x = startX_;

        my_moving_Baffle.y = startY_;

        my_moving_brick[].x = TopRow+DELTA;

        my_moving_brick[].y = LeftCol+;

        my_moving_brick[].speed = speed1;

        my_moving_brick[].dir = ;

        my_moving_brick[].flag = true;

        score = ;

        initscr();

        noecho();

        crmode();

        keypad( stdscr,true );

        //attroff( A_BLINK );

        if( flag==true ){

               mvaddstr( startX-,startY,"Do you want play game (y/n)?" );

               mvaddstr( startX-,startY,"Press 's' to slow (x-axis)");

               mvaddstr( startX-,startY,"Press 'f' to fast (x-axis)");

               mvaddstr( startX,startY,"Press 'S' to slow (y-axis)");

               mvaddstr( startX+,startY,"Press 'F' to slow (y-axis)");

               mvaddstr( startX+,startY,"Press '4' to the left");

               mvaddstr( startX+,startY,"Press '6' to the right");

               mvaddstr( startX+,startY,"(Please refer to the ReadMe.)");

               move( LINES-,COLS- );

               refresh();

               od = getch();

               if( od=='y'||od=='Y' ){ clear_up(); }

               else {

                      wrap_up();

                      return false;

               }

        }

        /* 游戏最开始进入界面 */      

        show_score_gameon();

        signal( SIGINT,solve_sigint );

        signal( SIGQUIT,solve_sigquit );

        mvaddch( my_moving_ball.y_pos, my_moving_ball.x_pos, my_moving_ball.ball_symbol );

        show_baffle();

        show_my_moving_baffle();

        show_my_moving_brick( my_moving_brick[].x,my_moving_brick[].y );

        refresh();

        signal( SIGALRM, ball_move );

        //signal( SIGALRM, brick_move );

        set_ticker(  / TICKS_PER_SEC );

        return true;

 }

 /********************************************************

        启动二维弹球

        set up the game

 *********************************************************/

 void wrap_up(){

        set_ticker(  );

        beep();

        endwin();

 }

 /********************************************************

        终止二维弹球

        end up the game

 *********************************************************/

 void solve_sigint(){

        mvaddstr( ,,"You enter ctrl+C");

        return ;

 }

 /********************************************************

        solve the signal :ctrl + C

 *********************************************************/

 void show_my_moving_brick( int x,int y ){

        if( my_moving_brick[].flag==true ){

               mvaddstr( x,y,BRICK );

               move( LINES-,COLS- );

        }

        return ;

 }

 void cover_my_moving_brick( int x,int y ){

        mvaddstr( x,y,"     " );

        move( LINES-,COLS- );

        return ;

 }

 /********************************************************

        show my moving brick

 *********************************************************/

 void solve_sigquit(){

        mvaddstr( ,,"You enter ctrl+\\");

        return ;

 }

 /********************************************************

        solve the signal :ctrl + \

 *********************************************************/

 void show_score_gameon(){

        move( , );

        addstr( Tip1 );

        char str1[  ],str2[  ];

        int cnt1 = ,cnt2 = ;

        int tp = score/;

        int i;

        while( tp ){

               str1[ cnt1++ ] = tp% + '';

               tp /= ;

        }

        for( i=cnt1-;i>=;i-- ){

               str2[ cnt2++ ] = str1[ i ];

        }

        if( cnt2== ) str2[ cnt2++ ] = '';

        str2[ cnt2 ] = '\0';

        addstr( "\nYour Score:" );

        addstr( str2 );

        move( LINES-,COLS- );

 }

 /********************************************************

        显示得分

        show the score

 *********************************************************/

 void show_score_gameoff(){

        move( , );

        addstr( Tip2 );

        char str1[  ],str2[  ];

        int cnt1 = ,cnt2 = ;

        int tp = score;

        int i;

        while( tp ){

               str1[ cnt1++ ] = tp% + '';

               tp /= ;

        }

        for( i=cnt1-;i>=;i-- ){

               str2[ cnt2++ ] = str1[ i ];

        }

        if( cnt2== ) str2[ cnt2++ ] = '';

        str2[ cnt2 ] = '\0';

        move( LINES/,COLS/ );

        addstr( Tip2 );

        mvaddstr( LINES/+,COLS/,"You can input 'P' to play again." );

        move( LINES-,COLS- );

 }

 /********************************************************

        show game over

 *********************************************************/

 void ball_move(){

        signal( SIGALRM,SIG_IGN );

        bool moved = false;

        int x_cur = my_moving_ball.x_pos;

        int y_cur = my_moving_ball.y_pos;

        bool crash_ed ;

        int yy_cur = my_moving_brick[].y;

        if( (my_moving_brick[].speed--)== ){

               my_moving_brick[].y +=my_moving_brick[].dir;

               if( my_moving_brick[].y+==RightCol||my_moving_brick[].y==LeftCol ) my_moving_brick[].dir *= (-);

               my_moving_brick[].speed = speed1;

        }

        cover_my_moving_brick( my_moving_brick[].x,yy_cur );

        show_my_moving_brick( my_moving_brick[].x,my_moving_brick[].y );

        move( LINES-,COLS- );

        refresh();

        //my_moving_brick

        if( my_moving_ball.x_Time1> && ((my_moving_ball.x_Time2--) == ) ){

               moved = true;

               my_moving_ball.x_pos += my_moving_ball.x_dir;

               my_moving_ball.x_Time2 = my_moving_ball.x_Time1;

        }

        if( my_moving_ball.y_Time1> && ((my_moving_ball.y_Time2--) == ) ){

               moved = true;

               my_moving_ball.y_pos += my_moving_ball.y_dir;

               my_moving_ball.y_Time2 = my_moving_ball.y_Time1;

        }

        if( moved == true ){

               crash_ed = ball_crash_brick();

               mvaddch( y_cur,x_cur,BLANK );

               mvaddch( my_moving_ball.y_pos,my_moving_ball.x_pos,my_moving_ball.ball_symbol );

               in_bound( &my_moving_ball );

               move( LINES-,COLS- );

               refresh();

        }

        signal( SIGALRM,ball_move );

        return ;

 }

 /********************************************************

        try move the ball

 *********************************************************/

 bool ball_crash_brick(){

        if( my_moving_ball.y_pos==my_moving_brick[].x ){

               if( my_moving_ball.x_pos>=my_moving_brick[].y&&my_moving_ball.x_pos<=my_moving_brick[].y+ ){

                      cover_my_moving_brick( my_moving_brick[].x,my_moving_brick[].y );

                      my_moving_brick[].flag = false;

                      return true;

               }

        }

        else

               return false;

 }

 /********************************************************

        when the ball crash with the brick

 *********************************************************/

 void in_bound( struct BallInfo *myballPoint ){

        bool return_dir = false;

        if( myballPoint->x_pos==LeftCol ){

               myballPoint->x_dir = ;

               return_dir = true;

        }//left

        else if( myballPoint->x_pos==RightCol ){

               myballPoint->x_dir = -;

               return_dir = true;

        }//right

        if( myballPoint->y_pos==TopRow ){

               myballPoint->y_dir = ;

               return_dir = true;

        }//up

        else if( myballPoint->y_pos==BotRow ){

               if( ((myballPoint->x_pos)>=my_moving_Baffle.y) && ((myballPoint->x_pos)<=my_moving_Baffle.y+my_moving_Baffle.len) ){

                      myballPoint->y_dir = -;

                      score ++;

                      show_score_gameon();

                      return_dir = true;

               }

               else{

                      show_score_gameoff();

                      wrap_up();

               }

        }//down

 }

 /********************************************************

        rebound the ball

 *********************************************************/

 int set_ticker( int n_msecs ){

        struct itimerval new_timeset;

        long n_sec, n_usecs;

        n_sec = n_msecs / ;

        n_usecs = ( n_msecs % ) * 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 );

 }

 /********************************************************

        set the timer

 *********************************************************/

 bool judge_in_bound( int x,int y ){

        if( x>=BotRow && x<=TopRow && y>=LeftCol && y<=RightCol )

               return true;

        else

               return false;

 }

 void show_baffle(){

        int i;

        for( i=TopRow-;i<=BotRow+;i++ ){

               mvaddch( i,LeftCol-,Baffle );

               mvaddch( i,RightCol+,Baffle );

        }

        for( i=LeftCol-;i<=RightCol+;i++ ){

               mvaddch( TopRow-,i,Baffle );

        }

        return ;

 }

 /********************************************************

        show the baffle

 *********************************************************/

 void try_move_my_moving_baffle( char od ){

        if( od==LEFT ){

               if( my_moving_Baffle.y- >= LeftCol ){

                      cover_my_moving_baffle();

                      my_moving_Baffle.y --;

                      show_my_moving_baffle();

               }

        }

        /* left */

        if( od==RIGHT ){

               if( my_moving_Baffle.y+my_moving_Baffle.len<=RightCol ){

                      cover_my_moving_baffle();

                      my_moving_Baffle.y ++;

                      show_my_moving_baffle();

               }

        }

        /* right */

 }

 /********************************************************

        solve my moving baffle's direction

 *********************************************************/

 void cover_my_moving_baffle(){

        int i;

        for( i=;i<my_moving_Baffle.len;i++ )

               mvaddch( my_moving_Baffle.x,my_moving_Baffle.y+i,BLANK );

        return ;

 }

 void show_my_moving_baffle(){

        int i;

        for( i=;i<my_moving_Baffle.len;i++ )

               mvaddch( my_moving_Baffle.x,my_moving_Baffle.y+i,my_moving_Baffle.baffle_symbol );

        return ;

 }

 /********************************************************

        show my moving baffle

 *********************************************************/

 int main(){

        char od;

        bool flag = set_up( true );

        /* start the game */

        if( flag==false )

               return ;

        /* the user dont want to play the game */

        while( ( od=getch() )!='Q' ){

               if( od=='f'&&my_moving_ball.x_Time1>Min ) my_moving_ball.x_Time1 --;

               else if( od=='s'&&my_moving_ball.x_Time1<Max ) my_moving_ball.x_Time1 ++;

               else if( od=='F'&&my_moving_ball.y_Time1>Min ) my_moving_ball.y_Time1 --;

               else if( od=='S'&&my_moving_ball.y_Time1<Max ) my_moving_ball.y_Time1 ++;

               /* change the ball's speed */

               if( od=='J'&&my_moving_Baffle.len>= ) {

                      cover_my_moving_baffle();

                      my_moving_Baffle.len --;

                      show_my_moving_baffle();

               }

               else if( od=='L'&&my_moving_Baffle.y+my_moving_Baffle.len<RightCol ){

                      cover_my_moving_baffle();

                      my_moving_Baffle.len ++;

                      show_my_moving_baffle();

               }

               /* change my moving baffle's len */

               if( od=='P' ) {

                      clear_up();

                      set_up( false );

               }

               /* play again the game */

               if( od==LEFT||od==RIGHT ){

                      try_move_my_moving_baffle( od );

               }

               /* move my moving baffle */

        }

        wrap_up();

        /* end up the game */

        return ;

 }

bounce.h

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

 #define BLANK ' '
 #define BALL 'o'
 #define Baffle '#'
 #define BaffleSymbol '_'

 #define TopRow 5
 #define BotRow 20
 #define LeftCol 10
 #define RightCol 70

 #define startX 10
 #define startY 10
 /* ball start position */

 #define startX_ 21
 #define startY_ 10
 #define BaffleLen 7
 /* baffle start position */

 #define scorePosx 1
 #define scorePosy 1
 #define Tip1 "GameOn:"
 #define Tip2 "GameOver"
 #define Tip3 "YourScore:"

 #define TICKS_PER_SEC 25

 #define X_Time 5
 #define Y_Time 8

 #define LEFT '4'
 #define RIGHT '6'

 #define Min 1
 #define Max 12

 #define foreground 34
 #define background 0
 #define colormode 0

 #define speed1 3
 #define speed2 3

 #define BRICK "BRICK"

 #define DELTA 5

 struct BallInfo{
 int x_pos,y_pos;
 int x_Time1,y_Time1;
 int x_Time2,y_Time2;
 int x_dir,y_dir;
 char ball_symbol;
 };

 struct BaffleInfo{
 int x,y,len;
 char baffle_symbol;
 };

 struct Brick{
 int x,y;
 int speed;
 int dir;
 bool flag;
 };