首页 手机软件 手机游戏 单机游戏 资讯文章 专题下载 游戏合集 文章合集 php下载 php教程 电脑软件
+ -
当前位置：首页 → 问答吧 → [原创]贡献一个蛋疼的俄罗斯方块小游戏

[原创]贡献一个蛋疼的俄罗斯方块小游戏

时间：2010-07-28

来源：互联网

本帖最后由 dave_cn 于 2010-07-28 20:20 编辑

我在Ubuntu 10.04下测试过，可以正常运行。不过界面让人蛋疼。
代码用到了NCURSES库。编译的时候链一下ncurses库就可以了，如：
cc -Wall -O2 -o c01 file.c -lncurses
界面：
下载 (9.4 KB)
2010-07-28 20:20

还请各位多多指教。
  1. /***************************************
  2. *
  3. * TETRIS
  4. *
  5. * author: dave
  6. * date  : 2010/07/28
  7. *
  8. ***************************************/
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <time.h>
  13. #include <sys/select.h>
  14. #include <sys/time.h>
  15. #include <sys/types.h>
  16. #include <unistd.h>
  17. #include <ncurses.h>

  19. #define TETRADS_LEN   4
  20. #define GAMEWIN_YLEN  20
  21. #define GAMEWIN_XLEN  10
  22. #define GAMEWIN_Y     1
  23. #define GAMEWIN_X     2
  24. #define INFOWIN_YLEN  10
  25. #define INFOWIN_XLEN  10
  26. #define INFOWIN_Y     GAMEWIN_Y
  27. #define INFOWIN_X     (GAMEWIN_X + GAMEWIN_XLEN*2 + 5)
  28. #define PIC_BLOCK     '#'
  29. #define PIC_NULL      ' '

  31. #define _X(x)         ((x)*2)

  33. #define BASEWIN \
  34.     WINDOW *win; \
  35.     void   (*init)(); \
  36.     void   (*show)();

  38. #define EXCHANGE_XY(_pos) \
  39.     do { \
  40.         (_pos).x = (_pos).y + (_pos).x; \
  41.         (_pos).y = (_pos).x - (_pos).y; \
  42.         (_pos).x -= (_pos).y; \
  43.     } while (0)

  45. #define EXCHANGE_2Y(_pos) \
  46.         (_pos).y = 2 - (_pos).y

  48. #define COPY_TETRADS(_dest, _src) \
  49.     memcpy(&(_dest), &(_src), sizeof(Tetrads))

  51. #define TETRISNEW(_p, _t) \
  52.     do { \
  53.         (_p) = (_t*)malloc(sizeof(_t)); \
  54.         (_p)->init = init##_t; \
  55.         (_p)->show = show##_t; \
  56.     } while (0)

  58. #define TETRISDEL(_p) \
  59.     do { \
  60.         delwin(_p->win); \
  61.         free(_p); \
  62.     } while (0)

  64. /* 俄罗斯方块的7种方块(Tetromino) */
  65. typedef enum {
  66.     TETRADS_S = 0,
  67.     TETRADS_Z,
  68.     TETRADS_L,
  69.     TETRADS_J,
  70.     TETRADS_O,
  71.     TETRADS_T,
  72.     TETRADS_I,
  73.    
  74.     TETRADS_MAX
  75. } ETetrads;

  77. typedef enum {
  78.     DIR_UP = 0,
  79.     DIR_DOWN,
  80.     DIR_LEFT,
  81.     DIR_RIGHT,
  82.    
  83.     DIR_MAX
  84. } EDirction;

  86. typedef enum {
  87.     TETRIS_STATE_NEW,
  88.     TETRIS_STATE_MOVE,
  89.     TETRIS_STATE_STOP,
  90.    
  91.     TETRIS_STATE_MAX,
  92. } ETetrisState;

  94. typedef struct {
  95.     int y;
  96.     int x;
  97. } Point;

  99. typedef struct {
  100.     ETetrads type;
  101.     Point    blocks[TETRADS_LEN];
  102. } Tetrads;

  104. /*** BEGIN : 界面显示 ***/ /* 将界面显示与数据处理分离 */
  105. typedef struct _BaseWin {
  106.     /**
  107.      * WINDOW *win;
  108.      * void   (*init)();
  109.      * void   (*show)();
  110.      */
  111.     BASEWIN
  112. } BaseWin;

  114. typedef struct _GameWin {
  115.     /**
  116.      * WINDOW *win;
  117.      * void   (*init)();
  118.      * void   (*show)();
  119.      */
  120.     BASEWIN

  122.     char    background[GAMEWIN_YLEN][GAMEWIN_XLEN];
  123.     char    matrix[GAMEWIN_YLEN][GAMEWIN_XLEN];
  124.     int     level;
  125.     Point   pos;
  126.     Tetrads curTetrads;
  127. } GameWin;

  129. typedef struct _InfoWin {
  130.     /**
  131.      * WINDOW *win;
  132.      * void   (*init)();
  133.      * void   (*show)();
  134.      */
  135.     BASEWIN

  137.     int     score;
  138.     int     level;
  139.     Tetrads nextTetrads;
  140. } InfoWin;

  142. void tetrisPrint(WINDOW *win, Point pos, Point block, char chr);

  144. void initGameWin(GameWin* _self)
  145. {
  146.     _self->win = newwin(GAMEWIN_YLEN + 2, _X(GAMEWIN_XLEN) + 1, GAMEWIN_Y, GAMEWIN_X);
  147.     box(_self->win, 0, 0);
  148.     mvwprintw(_self->win, 0, (_X(GAMEWIN_XLEN) + 2)/2 - 3, "TETRIS");
  149.     wrefresh(_self->win);

  151.     memset(_self->background, PIC_NULL, GAMEWIN_YLEN * GAMEWIN_XLEN);
  152.     memset(_self->matrix, PIC_NULL, GAMEWIN_YLEN * GAMEWIN_XLEN);

  154.     _self->pos = (Point){1, GAMEWIN_XLEN/2};
  155.     _self->level = 0;
  156. }

  158. void initInfoWin(InfoWin* _self)
  159. {
  160.     _self->win = newwin(INFOWIN_YLEN, _X(GAMEWIN_XLEN), INFOWIN_Y, INFOWIN_X);
  161.     box(_self->win, 0, 0);
  162.     mvwprintw(_self->win, 0, _X(GAMEWIN_XLEN)/2 - 2, "INFO");
  163.     mvwprintw(_self->win, 7, 2, "SCORE: 0");
  164.     mvwprintw(_self->win, 8, 2, "LEVEL: 0");
  165.     wrefresh(_self->win);

  167.     _self->score = 0;
  168.     _self->level = 0;
  169. }

  171. void showGameWin(GameWin* _self)
  172. {
  173.     int y = 0;
  174.     int x = 0;

  176.     for (y = 0; y < GAMEWIN_YLEN; ++y)
  177.         for (x = 0; x < GAMEWIN_XLEN; ++x)
  178.             tetrisPrint(_self->win, (Point){0, 0}, (Point){y, x}, (_self->background)[y][x]);

  180.     for (y = 0; y < GAMEWIN_YLEN; ++y)
  181.         for (x = 0; x < GAMEWIN_XLEN; ++x)
  182.             tetrisPrint(_self->win, (Point){0, 0}, (Point){y, x}, (_self->matrix)[y][x]);

  184.     for (x = 0; x < TETRADS_LEN; ++x)
  185.         tetrisPrint(_self->win, (Point){(_self->pos).y, (_self->pos).x}, (_self->curTetrads).blocks[x], PIC_BLOCK);

  187.     wrefresh(_self->win);
  188. }

  190. void showInfoWin(InfoWin* _self)
  191. {
  192.     int i = 0;
  193.    
  194.     mvwprintw(_self->win, 2, _X(INFOWIN_XLEN/2 - 2), "        ");
  195.     mvwprintw(_self->win, 3, _X(INFOWIN_XLEN/2 - 2), "        ");
  196.     mvwprintw(_self->win, 4, _X(INFOWIN_XLEN/2 - 2), "        ");
  197.     mvwprintw(_self->win, 5, _X(INFOWIN_XLEN/2 - 2), "        ");
  198.     mvwprintw(_self->win, 6, _X(INFOWIN_XLEN/2 - 2), "        ");

  200.     for (i = 0; i < TETRADS_LEN; ++i)
  201.         tetrisPrint(_self->win, (Point){2, INFOWIN_XLEN/2 - 2}, _self->nextTetrads.blocks[i], PIC_BLOCK);
  202.    
  203.     mvwprintw(_self->win, INFOWIN_YLEN - 3, 2, "SCORE: %d", _self->score);
  204.     mvwprintw(_self->win, INFOWIN_YLEN - 2, 2, "LEVEL: %d", _self->level);

  206.     wrefresh(_self->win);
  207. }
  208. /*** END   : 界面显示 ***/

  210. /*** 函数声明 ***/
  211. void newTetrads(Tetrads *tetrads);
  212. void initTetrads(Tetrads *tetrads);
  213. void spinTetrads(Tetrads *tetrads);
  214. int  runTetris(GameWin *gwin);
  215. int  checkBorder(GameWin *gwin);
  216. int  checkStop(GameWin *gwin);
  217. int  checkOver(GameWin *gwin);
  218. int  checkClean(GameWin *gwin);
  219. void refreshMatrix(GameWin *gwin);
  220. int  genRandom(int max);

  222. int main()
  223. {
  224.     /* init ncurses screen */
  225.     initscr();
  226.     raw();
  227.     noecho();
  228.     keypad(stdscr, TRUE);
  229.     curs_set(0);
  230.     refresh();

  232.     /* 初始化界面 */
  233.     GameWin *gwin;
  234.     InfoWin *iwin;

  236.     TETRISNEW(gwin, GameWin);
  237.     TETRISNEW(iwin, InfoWin);
  238.    
  239.     gwin->init(gwin);
  240.     iwin->init(iwin);

  242.     /* Tetris的处理使用简单的状态机实现 */
  243.     int f_end = 0;
  244.     int state = TETRIS_STATE_NEW;

  246.     newTetrads(&(iwin->nextTetrads));
  247.    
  248.     while (!f_end) {
  249.         switch (state) {
  250.         case TETRIS_STATE_NEW:
  251.             COPY_TETRADS(gwin->curTetrads, iwin->nextTetrads);
  252.             gwin->pos = (Point){1, 4};
  253.             newTetrads(&(iwin->nextTetrads));

  255.             iwin->show(iwin);
  256.             
  257.             state = TETRIS_STATE_MOVE;
  258.             break;
  259.         
  260.         case TETRIS_STATE_MOVE:
  261.             gwin->show(gwin);
  262.             
  263.             switch (runTetris(gwin)) {
  264.             case -1:
  265.                 goto END;
  266.                 break;
  267.             case 0:
  268.                 break;
  269.             case 1:
  270.                 state = TETRIS_STATE_STOP;
  271.                 break;
  272.             default:
  273.                 break;
  274.             }
  275.             
  276.             break;
  277.         
  278.         case TETRIS_STATE_STOP:
  279.             refreshMatrix(gwin);
  280.             iwin->score = checkClean(gwin);
  281.             state = TETRIS_STATE_NEW;
  282.             break;
  283.         
  284.         default :
  285.             f_end = 1;
  286.             break;
  287.         }
  288.     }

  290. END:
  291.     mvwprintw(gwin->win, GAMEWIN_YLEN/2 - 2, 5, "GAME OVER!!!");
  292.     mvwprintw(gwin->win, GAMEWIN_YLEN/2,     4, "Press any key");
  293.     mvwprintw(gwin->win, GAMEWIN_YLEN/2 + 1, 6, "to quit...");
  294.     wrefresh(gwin->win);
  295.    
  296.     getch();

  298.     TETRISDEL(iwin);
  299.     TETRISDEL(gwin);
  300.     endwin();
  301.    
  302.     return 0;
  303. }

  305. void tetrisPrint(WINDOW *win, Point pos, Point block, char chr)
  306. {
  307.     mvwaddch(win, pos.y + block.y + 1, (pos.x + block.x) * 2 + 1, chr);
  308. }

  310. void newTetrads(Tetrads *tetrads)
  311. {
  312.     tetrads->type = genRandom(TETRADS_MAX);
  313.    
  314.     initTetrads(tetrads);

  316.    
  317.     int spin = genRandom(DIR_MAX);
  318.     int i = 0;
  319.     for (; i <= spin; ++i) {
  320.         spinTetrads(tetrads);
  321.     }
  322. }

  324. void initTetrads(Tetrads *tetrads)
  325. {
  326.     switch (tetrads->type) {
  327.     case TETRADS_S:
  328.         tetrads->blocks[0] = (Point){2, 0};
  329.         tetrads->blocks[1] = (Point){2, 1};
  330.         tetrads->blocks[2] = (Point){1, 1};
  331.         tetrads->blocks[3] = (Point){1, 2};
  332.         break;

  334.     case TETRADS_Z:
  335.         tetrads->blocks[0] = (Point){1, 0};
  336.         tetrads->blocks[1] = (Point){1, 1};
  337.         tetrads->blocks[2] = (Point){2, 1};
  338.         tetrads->blocks[3] = (Point){2, 2};
  339.         break;

  341.     case TETRADS_L:
  342.         tetrads->blocks[0] = (Point){2, 0};
  343.         tetrads->blocks[1] = (Point){2, 1};
  344.         tetrads->blocks[2] = (Point){1, 1};
  345.         tetrads->blocks[3] = (Point){0, 1};
  346.         break;

  348.     case TETRADS_J:
  349.         tetrads->blocks[0] = (Point){0, 0};
  350.         tetrads->blocks[1] = (Point){1, 0};
  351.         tetrads->blocks[2] = (Point){1, 1};
  352.         tetrads->blocks[3] = (Point){1, 2};
  353.         break;

  355.     case TETRADS_O:
  356.         tetrads->blocks[0] = (Point){0, 0};
  357.         tetrads->blocks[1] = (Point){0, 1};
  358.         tetrads->blocks[2] = (Point){1, 0};
  359.         tetrads->blocks[3] = (Point){1, 1};
  360.         break;

  362.     case TETRADS_T:
  363.         tetrads->blocks[0] = (Point){0, 1};
  364.         tetrads->blocks[1] = (Point){1, 0};
  365.         tetrads->blocks[2] = (Point){1, 1};
  366.         tetrads->blocks[3] = (Point){1, 2};
  367.         break;

  369.     case TETRADS_I:
  370.         tetrads->blocks[0] = (Point){0, 1};
  371.         tetrads->blocks[1] = (Point){1, 1};
  372.         tetrads->blocks[2] = (Point){2, 1};
  373.         tetrads->blocks[3] = (Point){3, 1};
  374.         break;

  376.     default:
  377.         break;
  378.     }
  379. }

  381. /**
  382. * 旋转Tetrads
  383. */
  384. void spinTetrads(Tetrads *tetrads)
  385. {
  386.     int i = 0;
  387.    
  388.     switch (tetrads->type) {
  389.     case TETRADS_O:
  390.         break;

  392.     case TETRADS_I:
  393.         /* x,y互换 */
  394.         for (i = 0; i < TETRADS_LEN; ++i)
  395.             EXCHANGE_XY(tetrads->blocks[i]);
  396.         break;

  398.     default:
  399.         for (i = 0; i < TETRADS_LEN; ++i)
  400.             EXCHANGE_XY(tetrads->blocks[i]);

  402.         for (i = 0; i < TETRADS_LEN; ++i)
  403.             EXCHANGE_2Y(tetrads->blocks[i]);

  405.         break;
  406.     }
  407. }

  409. /**
  410. * Return:
  411. *   -1    game over
  412. *    0    continue
  413. *    1    stop
  414. */
  415. int runTetris(GameWin *gwin)
  416. {
  417.     int ret = 0;

  419.     fd_set fset;
  420.    
  421.     FD_ZERO(&fset);
  422.     FD_SET(0, &fset);
  423.    
  424.     struct timeval timeout;
  425.     timeout.tv_sec  = 0;
  426.     timeout.tv_usec = 500000 - 10000 * gwin->level;
  427.    
  428.     int fd = -1;
  429.     if ((fd = select(1, &fset, NULL, NULL, &timeout)) <= 0) {
  430.         ++((gwin->pos).y);
  431.         while (checkStop(gwin) != 0) {
  432.             --((gwin->pos).y);
  433.             ret = 1;
  434.         }

  436.         if (ret == 1) {
  437.             if (checkOver(gwin))
  438.                 return -1;

  440.             return 1;
  441.         }

  443.         return 0;
  444.     }

  446.     Tetrads tmptetrads;
  447.     char ch;
  448.     int  n = 0;
  449.     switch (ch = getch()) {
  450.     case 'w':
  451.         COPY_TETRADS(tmptetrads, gwin->curTetrads);
  452.         spinTetrads(&gwin->curTetrads);

  454.         while ((n = checkBorder(gwin)) != 0)
  455.             (gwin->pos).x += n;

  457.         while (checkStop(gwin) != 0) {
  458.             --((gwin->pos).y);
  459.             ret = 1;
  460.         }

  462.         return ret;

  464.     case 's':
  465.         ++((gwin->pos).y);
  466.         while (checkStop(gwin) != 0) {
  467.             --((gwin->pos).y);
  468.             ret = 1;
  469.         }

  471.         if (ret == 1) {
  472.             if (checkOver(gwin))
  473.                 return -1;

  475.             return 1;
  476.         }

  478.         return 0;

  480.     case 'a':
  481.         --((gwin->pos).x);
  482.         while ((n = checkBorder(gwin)) != 0)
  483.             (gwin->pos).x += n;
  484.         break;

  486.     case 'd':
  487.         ++((gwin->pos).x);
  488.         while ((n = checkBorder(gwin)) != 0)
  489.             (gwin->pos).x += n;
  490.         break;

  492.     default:
  493.         break;
  494.     }

  496.     return 0;
  497. }

  499. /**
  500. * 检查是否达到边线
  501. */
  502. int checkBorder(GameWin *gwin)
  503. {
  504.     int i = 0;
  505.     int n = 0;
  506.     for (i = 0; i < TETRADS_LEN; ++i) {
  507.         if ((n = ((gwin->pos).x + (gwin->curTetrads).blocks[i].x)) < 0)
  508.             return -n;

  510.         if ((n = ((gwin->pos).x + (gwin->curTetrads).blocks[i].x)) > GAMEWIN_XLEN - 1)
  511.             return GAMEWIN_XLEN - 1 - n;
  512.     }

  514.     return 0;
  515. }

  517. /**
  518. * 检查是否停止
  519. */
  520. int checkStop(GameWin *gwin)
  521. {
  522.     int i = 0;
  523.     for (i = 0; i < TETRADS_LEN; ++i)
  524.         if (gwin->matrix[(gwin->pos).y + (gwin->curTetrads).blocks[i].y][(gwin->pos).x + (gwin->curTetrads).blocks[i].x] == PIC_BLOCK
  525.             || ((gwin->pos).y + (gwin->curTetrads).blocks[i].y) >= GAMEWIN_YLEN)
  526.             return 1;

  528.     return 0;
  529. }

  531. /**
  532. * 检查是否游戏结束
  533. */
  534. int checkOver(GameWin *gwin)
  535. {
  536.     int i = 0;
  537.     for (i = 0; i < TETRADS_LEN; ++i)
  538.         if ((gwin->pos).y <= 0)
  539.             return 1;

  541.     return 0;
  542. }

  544. /**
  545. * 检查是否需要清楚一行
  546. */
  547. int checkClean(GameWin *gwin)
  548. {
  549.     char bline[GAMEWIN_XLEN];
  550.     memset(bline, PIC_BLOCK, GAMEWIN_XLEN);
  551.    
  552.     int i     = 0;
  553.     int num   = 0;
  554.     int score = 0;
  555.     for (i = 0; i < TETRADS_LEN; ++i) {
  556.         num = (gwin->pos).y + (gwin->curTetrads).blocks[i].y;
  557.         if (strncmp(gwin->matrix[num], bline, GAMEWIN_XLEN) == 0) {
  558.             score += 10;
  559.             for (; num > 0; --num)
  560.                 memcpy(gwin->matrix[num], gwin->matrix[num-1], GAMEWIN_XLEN);
  561.         }
  562.     }
  563.    
  564.     return score;
  565. }

  567. void refreshMatrix(GameWin *gwin)
  568. {
  569.     int i = 0;
  570.     for (i = 0; i < TETRADS_LEN; ++i)
  571.         gwin->matrix[(gwin->pos).y + (gwin->curTetrads).blocks[i].y][(gwin->pos).x + (gwin->curTetrads).blocks[i].x] = PIC_BLOCK;
  572. }

  574. /**
  575. * 返回0~max-1的一个随机数
  576. */
  577. int genRandom(int max)
  578. {
  579.     srandom((int)time(NULL));
  580.     return (random() % max);
  581. }
复制代码

作者: dave_cn   发布时间: 2010-07-28

不错，支持。

不过用printf也可以的

作者: okocha-jay   发布时间: 2010-07-28

相关阅读 更多

热门阅读

热门下载

更多
关于本站 免责申明 联系我们

Copyright 2006-2020 php爱好者(phpfans.net) All Rights Reserved.备案号：湘ICP备2023016114号-2

本站为非盈利性网站，不接受任何广告。本站所有资源均由网友上传，如有侵权，请发邮件至 [email protected] phpfans.net