Code666 (代码贴、代码片段)

[C++] 俄罗斯方块 →→→→→进入此内容的聊天室

来自 , 2019-10-28, 写在 C++, 查看 131 次.
URL http://www.code666.cn/view/5531a583
  1. /*
  2.  * 作者：did0602
  3.  * 出自：http://www.oschina.net/code/snippet_188854_13088
  4. */
  5.  
  6. #include <windows.h>
  7. #include <stdio.h>
  8. #include <time.h>
  9.  
  10. #define CELL 20
  11. #define ROWS 25
  12. #define COLS 15
  13. //升级所需分数值
  14. #define SCORE_LEVEL_INC 80
  15. #define ID_TIMER 1
  16.  
  17. /////////////////全局变量/////////////////////////////
  18. HWND hwnd;                                      //保存窗口句柄
  19.  
  20. int score=0;                            //分数
  21. int level=0;                            //级数
  22. int interval_unit=25;           //随级数递增的时间间隔增量
  23. int interval_base=300;          //时间间隔基量
  24. int old_interval;                       //保存当前的时间间隔，用于加速操作
  25.  
  26. int cur_left,cur_top;           //记录方块当前的位置
  27. int width_block,height_block;   //方块的宽带和高度
  28.  
  29. bool isPause=false;                             //暂停标识
  30. UINT timer_id=0;                                //保存计时器ID
  31.  
  32. static byte *block=NULL;                //方块，方块为随机大小，采用动态分配内存方式，所以这里是指针变量
  33. byte g_panel[ROWS][COLS]={0};
  34. ////////////////////////////////////////////////////
  35. LRESULT CALLBACK WndProc ( HWND,UINT,WPARAM,LPARAM );
  36. void DrawPanel ( HDC hdc );             //绘制表格
  37. void RefreshPanel ( HDC hdc );          //刷新面板
  38. void DoDownShift ( HDC hdc );           //下移
  39. void DoLeftShift ( HDC hdc );           //左移
  40. void DoRightShift ( HDC hdc );          //右移
  41. void DoAccelerate ( HDC hdc );          //加速
  42. void DoRedirection ( HDC hdc ); //改变方向
  43. void ClearRow ( HDC hdc );                      //消行
  44. bool ExportBlock();             //输出方块，
  45. //该函数会直接修改全局变量block,width_block,height_block,
  46. //cur_left和cur_top
  47. bool IsTouchBottom ( HDC hdc );                 //判断是否到达底部
  48.  
  49. int main()
  50. {
  51.         HINSTANCE hInstance=GetModuleHandle ( NULL );
  52.         TCHAR szAppName[]=TEXT ( "teris" );
  53.         MSG msg;
  54.         WNDCLASS wc;
  55.  
  56.         wc.style=CS_HREDRAW|CS_VREDRAW;
  57.         wc.lpfnWndProc=WndProc;
  58.         wc.cbClsExtra=0;
  59.         wc.cbWndExtra=0;
  60.         wc.hInstance=hInstance;
  61.         wc.hIcon=LoadIcon ( NULL,IDI_APPLICATION );
  62.         wc.hCursor=LoadCursor ( NULL,IDC_ARROW );
  63.         wc.hbrBackground= ( HBRUSH ) GetStockObject ( WHITE_BRUSH );
  64.         wc.lpszMenuName=NULL;
  65.         wc.lpszClassName=szAppName;
  66.         if ( !RegisterClass ( &wc ) )
  67.         {
  68.                 printf ( "RegisterClass occur errors!" );
  69.                 return 0;
  70.         }
  71.         hwnd=CreateWindow ( szAppName,TEXT ( "Teris Demo" ),
  72.                             WS_OVERLAPPEDWINDOW,
  73.                             0,0,0,0,
  74.                             NULL,
  75.                             NULL,
  76.                             hInstance,
  77.                             NULL );
  78.         ShowWindow ( hwnd,SW_SHOW );
  79.         UpdateWindow ( hwnd );
  80.         while ( GetMessage ( &msg,NULL,0,0 ) )
  81.         {
  82.                 TranslateMessage ( &msg );
  83.                 DispatchMessage ( &msg );
  84.         }
  85.         return msg.wParam;
  86. }
  87.  
  88. void DrawPanel ( HDC hdc )              //绘制游戏面板
  89. {
  90.         int x,y;
  91.         RECT rect;
  92.  
  93.         for ( y=0; y<ROWS; y++ )
  94.         {
  95.                 for ( x=0; x<COLS; x++ )
  96.                 {
  97.                         //计算方块的边框范围
  98.                         rect.top=y*CELL+1;
  99.                         rect.bottom= ( y+1 ) *CELL-1;
  100.                         rect.left=x*CELL+1;
  101.                         rect.right= ( x+1 ) *CELL-1;
  102.                         FrameRect ( hdc,&rect, ( HBRUSH ) GetStockObject ( BLACK_BRUSH ) );
  103.                 }
  104.         }
  105. }
  106.  
  107. void DoDownShift ( HDC hdc )            //下移
  108. {
  109.         if ( NULL==block ) return;
  110.  
  111.         //判断是否到达底部
  112.         if ( IsTouchBottom ( hdc ) )    //到底部
  113.         {
  114.                 //消行处理
  115.                 ClearRow ( hdc );
  116.                 ExportBlock();          //输出下一个方块
  117.         }
  118.  
  119.         cur_top++;
  120.         RefreshPanel ( hdc );
  121. }
  122.  
  123. void DoLeftShift ( HDC hdc )            //左移
  124. {
  125.         int x,y;
  126.         if ( NULL==block ) return;
  127.  
  128.         if ( 0==cur_left ) return;
  129.         if ( cur_top<0 ) return;        //方块没有完整显示前，不能左移
  130.         for ( y=0; y<height_block; y++ )
  131.         {
  132.                 for ( x=0; x<width_block; x++ )                 //从左边开始扫描，获取该行最左边的实心方格块
  133.                 {
  134.                         if ( * ( block+y*width_block+x ) )
  135.                         {
  136.                                 //判断当前方格在面板上面左边一个方格是否为实心，是就代表不能再左移
  137.                                 if ( g_panel[cur_top+y][cur_left+x-1] ) return;
  138.  
  139.                                 break;          //只判断最左边的一个实心方格，之后直接扫描下一行
  140.                         }
  141.                 }
  142.         }
  143.         cur_left--;
  144.         RefreshPanel ( hdc );
  145. }
  146.  
  147. void DoRightShift ( HDC hdc )           //右移
  148. {
  149.         int x,y;
  150.         if ( NULL==block ) return;
  151.  
  152.         if ( COLS-width_block==cur_left ) return;
  153.         if ( cur_top<0 ) return;                //方块完整显示前不能右移
  154.         for ( y=0; y<height_block; y++ )
  155.         {
  156.                 for ( x=width_block-1; x>=0; x-- )      //从右边开始扫描，获取该行最右边的实心方格块
  157.                 {
  158.                         if ( * ( block+y*width_block+x ) )
  159.                         {
  160.                                 //判断当前方格在面板上右边一个方格是否为实心，是就代表不能再右移
  161.                                 if ( g_panel[cur_top+y][cur_left+x+1] ) return;
  162.  
  163.                                 break;          //只判断最右边的一个实心方格
  164.                         }
  165.                 }
  166.         }
  167.         cur_left++;
  168.         RefreshPanel ( hdc );
  169. }
  170.  
  171. void DoRedirection ( HDC hdc )          //改变方向
  172. {
  173.         int i,j;
  174.         byte * temp=NULL;
  175.         if ( NULL==block ) return;
  176.         if ( cur_top<0 ) return;                //方块完整显示前不能转向
  177.  
  178.         temp= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  179.         for ( i=0; i<width_block; i++ )
  180.         {
  181.                 for ( j=0; j<height_block; j++ )
  182.                 {
  183.                         //temp[i][j]=block[height_block-j-1][i];
  184.                         * ( temp+i*height_block+j ) =* ( block+ ( height_block-j-1 ) *width_block+i );
  185.                 }
  186.         }
  187.  
  188.         //给方块重新定位
  189.         int incHeight=width_block-height_block;
  190.         int incWidth=height_block-width_block;
  191.         int temp_cur_top=cur_top-incHeight/2;
  192.         int temp_cur_left=cur_left-incWidth/2;
  193.  
  194.         //system("cls");
  195.         //printf("temp_top=%d, temp_left=%d",temp_cur_top,temp_cur_left);
  196.  
  197.         //判断当前空间是否足够让方块改变方向
  198.         int max_len=max ( width_block,height_block );
  199.         //防止下标访问越界
  200.         if ( temp_cur_top+max_len-1>=ROWS||temp_cur_left<0||temp_cur_left+max_len-1>=COLS )
  201.         {
  202.                 free ( temp );          //退出前必须先释放内存
  203.                 return;
  204.         }
  205.         for ( i=0; i<max_len; i++ )
  206.         {
  207.                 for ( j=0; j<max_len; j++ )
  208.                 {
  209.                         //转向所需的空间内有已被占用的实心方格存在，即转向失败
  210.                         if ( g_panel[temp_cur_top+i][temp_cur_left+j] )
  211.                         {
  212.                                 free ( temp );          //退出前必须先释放内存
  213.                                 return;
  214.                         }
  215.                 }
  216.         }
  217.  
  218.         //把临时变量的值赋给block，只能赋值，而不能赋指针值
  219.         for ( i=0; i<height_block; i++ )
  220.         {
  221.                 for ( j=0; j<width_block; j++ )
  222.                 {
  223.                         //block[i][j]=temp[i][j];
  224.                         * ( block+i*width_block+j ) =* ( temp+i*width_block+j );
  225.                 }
  226.         }
  227.  
  228.         //全局变量重新被赋值
  229.         cur_top=temp_cur_top;
  230.         cur_left=temp_cur_left;
  231.         //交换
  232.         i=width_block;
  233.         width_block=height_block;
  234.         height_block=i;
  235.  
  236.         free ( temp );          //释放为临时变量分配的内存
  237.         RefreshPanel ( hdc );
  238. }
  239.  
  240. void DoAccelerate ( HDC hdc )           //加速
  241. {
  242.         if ( NULL==block ) return;
  243.  
  244.         if ( IsTouchBottom ( hdc ) )
  245.         {
  246.                 //消行处理
  247.                 ClearRow ( hdc );
  248.                 ExportBlock();
  249.         }
  250.         cur_top++;
  251.         RefreshPanel ( hdc );
  252. }
  253.  
  254. bool IsTouchBottom ( HDC hdc )
  255. {
  256.         int x,y;
  257.         int i,j;
  258.  
  259.         if ( NULL==block ) return false;
  260.         if ( ROWS==cur_top+height_block )
  261.         {
  262.                 //固定方块
  263.                 for ( i=0; i<height_block; i++ )
  264.                 {
  265.                         for ( j=0; j<width_block; j++ )
  266.                         {
  267.                                 if ( * ( block+i*width_block+j ) ) g_panel[cur_top+i][cur_left+j]=1;
  268.                         }
  269.                 }
  270.                 return true;
  271.         }
  272.         for ( y=height_block-1; y>=0; y-- )             //从底行开始扫描
  273.         {
  274.                 //判断第一个实心方块在面板上邻接的下方方格是否为实心，是就代表已经到达底部
  275.                 for ( x=0; x<width_block; x++ )
  276.                 {
  277.                         if ( * ( block+y*width_block+x ) )
  278.                         {
  279.                                 if ( cur_top+y+1<0 ) return false;
  280.                                 if ( g_panel[cur_top+y+1][cur_left+x] )
  281.                                 {
  282.                                         //判断是否gameover
  283.                                         if ( cur_top<=0 )
  284.                                         {
  285.                                                 if ( timer_id )
  286.                                                 {
  287.                                                         KillTimer ( hwnd,ID_TIMER );
  288.                                                         timer_id=0;
  289.                                                 }
  290.                                                 MessageBox ( hwnd,TEXT ( "游戏结束" ),TEXT ( "MSG" ),MB_OK|MB_ICONEXCLAMATION );
  291.                                                 SendMessage ( hwnd,WM_CLOSE,0,0 );
  292.                                         }
  293.                                         //
  294.                                         //固定方块
  295.                                         for ( i=0; i<height_block; i++ )
  296.                                         {
  297.                                                 for ( j=0; j<width_block; j++ )
  298.                                                 {
  299.                                                         if ( * ( block+i*width_block+j ) ) g_panel[cur_top+i][cur_left+j]=1;
  300.                                                 }
  301.                                         }
  302.                                         return true;
  303.                                 }
  304.                         }
  305.                 }
  306.         }
  307.         return false;
  308. }
  309.  
  310. void ClearRow ( HDC hdc )                               //消行
  311. {
  312.         int i,j,k;
  313.         int count=0;            //消行次数
  314.         bool isFilled;
  315.         //消行处理
  316.         for ( i=ROWS-1; i>=0; i-- )
  317.         {
  318.                 isFilled=true;
  319.                 for ( j=0; j<COLS; j++ )
  320.                 {
  321.                         if ( !g_panel[i][j] )
  322.                         {
  323.                                 isFilled=false;
  324.                                 break;
  325.                         }
  326.                 }
  327.                 if ( isFilled )
  328.                 {
  329.                         for ( j=0; j<COLS; j++ )
  330.                         {
  331.                                 g_panel[i][j]=0;
  332.                         }
  333.                         //所有方块往下移
  334.                         for ( k=i-1; k>=0; k-- )
  335.                         {
  336.                                 for ( j=0; j<COLS; j++ )
  337.                                 {
  338.                                         g_panel[k+1][j]=g_panel[k][j];
  339.                                 }
  340.                         }
  341.                         i=i+1;
  342.                         count++;
  343.                 }
  344.         }
  345.  
  346.         //最高级别为9级，所以分数极限为(9+1)*SCORE_LEVEL_INC-1
  347.         if ( score>=10*SCORE_LEVEL_INC-1 ) return;
  348.  
  349.         //加分规则：消除行数，1行加10分，2行加15分,3行加20分,4行加30分
  350.         switch ( count )
  351.         {
  352.         case 1:
  353.                 score+=10;
  354.                 break;
  355.         case 2:
  356.                 score+=15;
  357.                 break;
  358.         case 3:
  359.                 score+=20;
  360.                 break;
  361.         case 4:
  362.                 score+=30;
  363.                 break;
  364.         }
  365.  
  366.         int temp_level=score/SCORE_LEVEL_INC;
  367.         if ( temp_level>level )
  368.         {
  369.                 level=temp_level;
  370.                 //撤销当前计时器，然后重设
  371.                 if ( timer_id ) KillTimer ( hwnd,ID_TIMER );
  372.                 timer_id=SetTimer ( hwnd,ID_TIMER,interval_base-level*interval_unit,NULL );
  373.         }
  374.  
  375.         system ( "cls" );
  376.         printf ( "score: %d, level: %d ",score,level );
  377. }
  378.  
  379. void RefreshPanel ( HDC hdc )                   //刷新面板
  380. {
  381.         int x,y;
  382.         RECT rect;
  383.         HBRUSH h_bSolid= ( HBRUSH ) GetStockObject ( GRAY_BRUSH ),
  384.                          h_bEmpty= ( HBRUSH ) GetStockObject ( WHITE_BRUSH );
  385.         if ( NULL==block ) return;
  386.  
  387.         //先刷屏
  388.         for ( y=0; y<ROWS; y++ )
  389.         {
  390.                 for ( x=0; x<COLS; x++ )
  391.                 {
  392.                         //为避免刷掉方块的边框，rect范围必须比边框范围小1
  393.                         rect.top=y*CELL+2;
  394.                         rect.bottom= ( y+1 ) *CELL-2;
  395.                         rect.left=x*CELL+2;
  396.                         rect.right= ( x+1 ) *CELL-2;
  397.                         if ( g_panel[y][x] )
  398.                                 FillRect ( hdc,&rect,h_bSolid );
  399.                         else
  400.                                 FillRect ( hdc,&rect,h_bEmpty );
  401.                 }
  402.         }
  403.         //再定位方块
  404.         for ( y=0; y<height_block; y++ )
  405.         {
  406.                 for ( x=0; x<width_block; x++ )
  407.                 {
  408.                         if ( * ( block+y*width_block+x ) )              //实心
  409.                         {
  410.                                 rect.top= ( y+cur_top ) *CELL+2;
  411.                                 rect.bottom= ( y+cur_top+1 ) *CELL-2;
  412.                                 rect.left= ( x+cur_left ) *CELL+2;
  413.                                 rect.right= ( x+cur_left+1 ) *CELL-2;
  414.                                 FillRect ( hdc,&rect,h_bSolid );
  415.                         }
  416.                 }
  417.         }
  418. }
  419.  
  420. bool ExportBlock()              //输出方块
  421. {
  422.         int sel;
  423.         if ( block )
  424.         {
  425.                 free ( block );         //释放之前分配的内存
  426.                 block=NULL;
  427.         }
  428.  
  429.         sel=rand() %7;
  430.         switch ( sel )
  431.         {
  432.         case 0:         //水平条
  433.                 width_block=4;
  434.                 height_block=1;
  435.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  436.                 * ( block+0 ) =1;               //可以理解为*(block+0*width_block+0)=1，即第一行的第一个方格，下面同理
  437.                 * ( block+1 ) =1;               //*(block+0*width_block+1)=1
  438.                 * ( block+2 ) =1;               //*(block+0*width_block+2)=1
  439.                 * ( block+3 ) =1;               //*(block+0*width_block+3)=1
  440.  
  441.                 cur_top=0-height_block;
  442.                 cur_left= ( COLS-width_block ) /2;
  443.                 break;
  444.         case 1:         //三角
  445.                 width_block=3;
  446.                 height_block=2;
  447.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  448.                 * ( block+0 ) =0;               //可以理解为*(block+0*width_block+0)=0，即第一行的第一个方格，下面同理
  449.                 * ( block+1 ) =1;               //*(block+0*width_block+1)=1
  450.                 * ( block+2 ) =0;               //*(block+0*width_block+2)=0
  451.                 * ( block+3 ) =1;               //*(block+1*width_block+0)=1，第二行开始
  452.                 * ( block+4 ) =1;               //*(block+1*width_block+1)=1
  453.                 * ( block+5 ) =1;               //*(block+1*width_block+2)=1
  454.  
  455.                 cur_top=0-height_block;
  456.                 cur_left= ( COLS-width_block ) /2;
  457.                 break;
  458.         case 2:         //左横折
  459.                 width_block=3;
  460.                 height_block=2;
  461.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  462.                 * ( block+0 ) =1;               //可以理解为*(block+0*width_block+0)=1，下面同理
  463.                 * ( block+1 ) =0;               //*(block+0*width_block+1)=0
  464.                 * ( block+2 ) =0;               //*(block+0*width_block+2)=0
  465.                 * ( block+3 ) =1;               //*(block+1*width_block+0)=1
  466.                 * ( block+4 ) =1;               //*(block+1*width_block+1)=1
  467.                 * ( block+5 ) =1;               //*(block+1*width_block+2)=1
  468.  
  469.                 cur_top=0-height_block;
  470.                 cur_left= ( COLS-width_block ) /2;
  471.                 break;
  472.         case 3:         //右横折
  473.                 width_block=3;
  474.                 height_block=2;
  475.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  476.                 * ( block+0 ) =0;               //可以理解为*(block+0*width_block+0)=0，下面同理
  477.                 * ( block+1 ) =0;               //*(block+0*width_block+1)=0
  478.                 * ( block+2 ) =1;               //*(block+0*width_block+2)=1
  479.                 * ( block+3 ) =1;               //*(block+1*width_block+0)=1
  480.                 * ( block+4 ) =1;               //*(block+1*width_block+1)=1
  481.                 * ( block+5 ) =1;               //*(block+1*width_block+2)=1
  482.  
  483.                 cur_top=0-height_block;
  484.                 cur_left= ( COLS-width_block ) /2;
  485.                 break;
  486.         case 4:         //左闪电
  487.                 width_block=3;
  488.                 height_block=2;
  489.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  490.                 * ( block+0 ) =1;               //可以理解为*(block+0*width_block+0)=1，下面同理
  491.                 * ( block+1 ) =1;               //*(block+0*width_block+1)=1
  492.                 * ( block+2 ) =0;               //*(block+0*width_block+2)=0
  493.                 * ( block+3 ) =0;               //*(block+1*width_block+0)=0
  494.                 * ( block+4 ) =1;               //*(block+1*width_block+1)=1
  495.                 * ( block+5 ) =1;               //*(block+1*width_block+2)=1
  496.  
  497.                 cur_top=0-height_block;
  498.                 cur_left= ( COLS-width_block ) /2;
  499.                 break;
  500.         case 5:         //右闪电
  501.                 width_block=3;
  502.                 height_block=2;
  503.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  504.                 * ( block+0 ) =0;               //可以理解为*(block+0*width_block+0)=0，下面同理
  505.                 * ( block+1 ) =1;               //*(block+0*width_block+1)=1
  506.                 * ( block+2 ) =1;               //*(block+0*width_block+2)=1
  507.                 * ( block+3 ) =1;               //*(block+1*width_block+0)=1
  508.                 * ( block+4 ) =1;               //*(block+1*width_block+1)=1
  509.                 * ( block+5 ) =0;               //*(block+1*width_block+2)=0
  510.  
  511.                 cur_top=0-height_block;
  512.                 cur_left= ( COLS-width_block ) /2;
  513.                 break;
  514.         case 6:         //石头
  515.                 width_block=2;
  516.                 height_block=2;
  517.                 block= ( byte * ) malloc ( sizeof ( byte ) *width_block*height_block );
  518.                 * ( block+0 ) =1;               //可以理解为*(block+0*width_block+0)=1，下面同理
  519.                 * ( block+1 ) =1;               //*(block+0*width_block+1)=1
  520.                 * ( block+2 ) =1;               //*(block+1*width_block+0)=1
  521.                 * ( block+3 ) =1;               //*(block+1*width_block+1)=1
  522.  
  523.                 cur_top=0-height_block;
  524.                 cur_left= ( COLS-width_block ) /2;
  525.                 break;
  526.         }
  527.         return block!=NULL;
  528. }
  529.  
  530. LRESULT CALLBACK WndProc ( HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam )
  531. {
  532.         HDC hdc;
  533.         PAINTSTRUCT ps;
  534.         //TCHAR szBuffer[1024];
  535.  
  536.         switch ( message )
  537.         {
  538.         case WM_CREATE:
  539.                 MoveWindow ( hwnd,400,10,CELL*COLS+8,CELL*ROWS+32,FALSE );              //补齐宽度和高度
  540.                 srand ( time ( NULL ) );
  541.                 ExportBlock();
  542.  
  543.                 timer_id=SetTimer ( hwnd,ID_TIMER,interval_base-level*interval_unit,NULL );
  544.                 return 0;
  545.         case WM_TIMER:
  546.                 hdc=GetDC ( hwnd );
  547.                 DoDownShift ( hdc );
  548.                 ReleaseDC ( hwnd,hdc );
  549.                 return 0;
  550.         case WM_KEYDOWN:
  551.                 hdc=GetDC ( hwnd );
  552.                 switch ( wParam )
  553.                 {
  554.                 case VK_LEFT:                                                   //左移
  555.                         if ( !isPause ) DoLeftShift ( hdc );
  556.                         break;
  557.                 case VK_RIGHT:                                                  //右移
  558.                         if ( !isPause ) DoRightShift ( hdc );
  559.                         break;
  560.                 case VK_UP:                                                             //转向
  561.                         if ( !isPause ) DoRedirection ( hdc );
  562.                         break;
  563.                 case VK_DOWN:                                                   //加速
  564.                         if ( !isPause ) DoAccelerate ( hdc );
  565.                         break;
  566.                 case VK_SPACE:          //暂停
  567.                         isPause=!isPause;
  568.                         if ( isPause )
  569.                         {
  570.                                 if ( timer_id ) KillTimer ( hwnd,ID_TIMER );
  571.                                 timer_id=0;
  572.                         }
  573.                         else
  574.                         {
  575.                                 timer_id=SetTimer ( hwnd,ID_TIMER,interval_base-level*interval_unit,FALSE );
  576.                         }
  577.                         break;
  578.                 }
  579.                 ReleaseDC ( hwnd,hdc );
  580.                 return 0;
  581.         case WM_PAINT:
  582.                 hdc=BeginPaint ( hwnd,&ps );
  583.                 DrawPanel ( hdc );                      //绘制面板
  584.                 RefreshPanel ( hdc );           //刷新
  585.                 EndPaint ( hwnd,&ps );
  586.                 return 0;
  587.         case WM_DESTROY:
  588.                 if ( block ) free ( block );
  589.                 if ( timer_id ) KillTimer ( hwnd,ID_TIMER );
  590.                 PostQuitMessage ( 0 );
  591.                 return 0;
  592.         }
  593.         return DefWindowProc ( hwnd,message,wParam,lParam );
  594. }

回复 "俄罗斯方块"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666