网友C的俄罗斯方块程序

最新推荐文章于 2021-07-13 17:28:52 发布
最新推荐文章于 2021-07-13 17:28:52 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： WIN32 编程 文章标签： c timer null 游戏 callback dependencies
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anyue417/article/details/950153
版权

这是他做的俄罗斯方块：

 

 

下面是他的代码，他是在VS2003中写得，我没用过，哈哈，有些格式还不清楚呢，他的代码比我的干净，整齐多了，这方面我要好好注意下才行。

///stdafx.h///

// stdafx.h : 标准系统包含文件的包含文件，
// 或是常用但不常更改的项目特定的包含文件
//

#pragma once


#define WIN32_LEAN_AND_MEAN  // 从 Windows 头中排除极少使用的资料
// Windows 头文件:
#include <windows.h>
// C 运行时头文件
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>

// TODO: 在此处引用程序要求的附加头文件

 

//resource.h

//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by Tetris.rc
//
#define IDC_MYICON                      2
#define IDD_TETRIS_DIALOG               102
#define IDS_APP_TITLE                   103
#define IDD_ABOUTBOX                    103
#define IDM_ABOUT                       104
#define IDM_EXIT                        105
#define IDI_TETRIS                      107
#define IDI_SMALL                       108
#define IDC_TETRIS                      109
#define IDR_MAINFRAME                   128
#define ID_Menu                         32772
#define IDM_PAUSE                       32774
#define IDM_NEW                         32775
#define IDC_STATIC                      -1

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NO_MFC                     1
#define _APS_NEXT_RESOURCE_VALUE        129
#define _APS_NEXT_COMMAND_VALUE         32776
#define _APS_NEXT_CONTROL_VALUE         1001
#define _APS_NEXT_SYMED_VALUE           110
#endif
#endif

 

/Tetris.h//

#pragma once

#include "resource.h"
///

 

/Tetrisdata.h//

#include <time.h>

#define X 12      //定义一行方块的数目
#define Y 25      //定义一列方块的数目
#define COL 4      //定义显示方块使用的颜色数量


//函数声明：
extern int createblock(void);
extern int loadblock(void);
extern int gameinit();
extern int moveright();
extern int moveleft();
extern int movedown();
extern int canmove(int);
extern int turn();
extern int isbottom();
extern int clear();
extern int downline(int line);

 

static int tetris[Y+5][X+2];  //整个游戏区域的数组


//存储所有方块的形态的数组
static int block[19][16]={
0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,/*11*/
0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,/*12*/
0,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,/*21*/
0,0,0,0,1,0,0,0,1,1,0,0,0,1,0,0,/*22*/
0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,0,/*31*/
0,0,0,0,1,0,0,0,1,0,0,0,1,1,0,0,/*32*/
0,0,0,0,0,0,1,0,1,1,1,0,0,0,0,0,/*33*/
0,0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,/*34*/
0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,0,/*41*/
0,0,0,0,0,1,0,0,0,1,0,0,1,1,0,0,/*42*/
0,0,0,0,1,1,1,0,0,0,1,0,0,0,0,0,/*43*/
0,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,/*44*/
0,0,0,0,0,1,0,0,1,1,1,0,0,0,0,0,/*51*/
0,0,0,0,0,1,0,0,1,1,0,0,0,1,0,0,/*52*/
0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,/*53*/
0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,/*54*/
0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,/*61*/
0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,/*62*/
0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0};/*71*/

static int bxy[4][2];    //当前方块的四个基本位置坐标

int current;      //当前方块的种类（作为数组block的第一维）
int next;       //下一个方块的种类
int speed;       //当前游戏速度
int score;       //当前游戏得分
int level;       //当前游戏关数

long timer;       //用于游戏控制定时器的变量
bool gameover;      //游戏结束的标志
bool pause;       //游戏暂停的标志
bool readonly;      //数组bxy可以被修改的标志

 

/

 

/stdafx.cpp///

// stdafx.cpp : 只包括标准包含文件的源文件
// Tetris.pch 将成为预编译头
// stdafx.obj 将包含预编译类型信息

#include "stdafx.h"

// TODO: 在 STDAFX.H 中
//引用任何所需的附加头文件，而不是在此文件中引用
///

 

//Tetris.cpp//

// Tetris.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "Tetris.h"
#include "Tetrisdata.h"       //存储游戏数据结构，全局变量以及函数声明
#define MAX_LOADSTRING 100

//#define TIMER_PRINT 1       //窗口刷新定时器ID
#define TIMER_DOWN 1       //游戏控制定时器ID
#define BLOCKLEN 15        //绘图时单位方块的边长
#define TIMELEVEL 75       //每过一关后游戏时间间隔的减少量
#define INITSPEED 700       //第一关游戏时间间隔量
#define SCOREPERLEVEL 200      //过一关需要的分数

// 全局变量:
HINSTANCE hInst;        // 当前实例
TCHAR szTitle[MAX_LOADSTRING];     // 标题栏文本
TCHAR szWindowClass[MAX_LOADSTRING];   // 主窗口类名

// 此代码模块中包含的函数的前向声明:
ATOM    MyRegisterClass(HINSTANCE hInstance);
BOOL    InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
VOID CALLBACK PrintProc (HWND, UINT, UINT, DWORD);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
  // TODO: 在此放置代码。
 MSG msg;
 HACCEL hAccelTable;

 // 初始化全局字符串
 LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
 LoadString(hInstance, IDC_TETRIS, szWindowClass, MAX_LOADSTRING);
 MyRegisterClass(hInstance);

 // 执行应用程序初始化:
 if (!InitInstance (hInstance, nCmdShow))
 {
  return FALSE;
 }

 hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TETRIS);

 // 主消息循环:
 while (GetMessage(&msg, NULL, 0, 0))
 {
  if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
  {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
  }
 }

 return (int) msg.wParam;
}

 

//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
//  注释:
//
//    仅当希望在已添加到 Windows 95 的
//    “RegisterClassEx”函数之前此代码与 Win32 系统兼容时，
//    才需要此函数及其用法。调用此函数
//    十分重要，这样应用程序就可以获得关联的
//   “格式正确的”小图标。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
 WNDCLASSEX wcex;

 wcex.cbSize = sizeof(WNDCLASSEX);

 wcex.style   = CS_HREDRAW | CS_VREDRAW;
 wcex.lpfnWndProc = (WNDPROC)WndProc;
 wcex.cbClsExtra  = 0;
 wcex.cbWndExtra  = 0;
 wcex.hInstance  = hInstance;
 wcex.hIcon   = LoadIcon(hInstance, (LPCTSTR)IDI_TETRIS);
 wcex.hCursor  = LoadCursor(NULL, IDC_ARROW);
 wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 wcex.lpszMenuName = (LPCTSTR)IDC_TETRIS;
 wcex.lpszClassName = szWindowClass;
 wcex.hIconSm  = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

 return RegisterClassEx(&wcex);
}

//
//   函数: InitInstance(HANDLE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释:
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // 将实例句柄存储在全局变量中

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPED|WS_SYSMENU|WS_BORDER|WS_MINIMIZEBOX,
      CW_USEDEFAULT, CW_USEDEFAULT, (X+6)*BLOCKLEN, (Y+3)*BLOCKLEN, NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  函数: WndProc(HWND, unsigned, WORD, LONG)
//
//  目的: 处理主窗口的消息。
//
//  WM_COMMAND - 处理应用程序菜单
//  WM_PAINT - 绘制主窗口
//  WM_DESTROY - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
 int wmId, wmEvent;
 PAINTSTRUCT ps;
 HDC hdc;

 switch (message)
 {
 case WM_COMMAND:
  wmId    = LOWORD(wParam);
  wmEvent = HIWORD(wParam);
  if (!pause)ModifyMenu(GetMenu(hWnd),IDM_PAUSE,MF_BYCOMMAND,IDM_PAUSE,"继续");
  else ModifyMenu(GetMenu(hWnd),IDM_PAUSE,MF_BYCOMMAND,IDM_PAUSE,"暂停");
  // 分析菜单选择:
  switch (wmId)
  {
  case IDM_NEW:
   gameinit();
   break;
  case IDM_PAUSE:
   if (pause) pause = FALSE;
   else pause = TRUE;
   break;
  case IDM_ABOUT:
   DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
   break;
  case IDM_EXIT:
   DestroyWindow(hWnd);
   break;
  default:
   return DefWindowProc(hWnd, message, wParam, lParam);
  }
  break;
 case WM_CREATE:
  static HBRUSH brush[4];
  brush[0] = CreateSolidBrush(RGB(0,0,255) );
  brush[1] = CreateSolidBrush(RGB(255,20,147));
  brush[2] = CreateSolidBrush(RGB(0,255,0));
  brush[3] = CreateSolidBrush(RGB(255,193,37));
  gameinit();
  pause = TRUE;
  //SetTimer(hWnd,TIMER_PRINT,500,NULL);
  timer = 0;
  SetTimer(hWnd,TIMER_DOWN,TIMELEVEL,NULL);
  break;
 case WM_TIMER:
  switch (wParam){
/*   case TIMER_PRINT:
                InvalidateRect (hWnd, NULL, TRUE) ;
    break;*/
   case TIMER_DOWN:
    if (pause)break;
    else {
     if(timer < speed){
      timer += TIMELEVEL;
      break;
     }
     else {
      if(canmove(3)){
       movedown();
       InvalidateRect (hWnd, NULL, TRUE) ;
       timer = TIMELEVEL;
      }
      else {
       isbottom();
       InvalidateRect (hWnd, NULL, TRUE) ;
       timer = TIMELEVEL;
      }
      if (gameover){
       pause = TRUE;
       if (MessageBox(hWnd,"Game Over!Retry?","Tetris",MB_YESNO)==IDYES)gameinit();
       else exit(0);
      }
     }
     break;
    }
   default : break;
  }
  break;
 case WM_PAINT:
  hdc = BeginPaint(hWnd, &ps);
  // TODO: 在此添加任意绘图代码...
  int i,j;
  //画方格：
  for (i=0; i<=X; i++){
   MoveToEx(hdc,i*BLOCKLEN,0,NULL);
   LineTo(hdc,i*BLOCKLEN,BLOCKLEN*(Y-1));
  }
  for (i=0; i<Y; i++){
   MoveToEx(hdc,0,i*BLOCKLEN,NULL);
   LineTo(hdc,BLOCKLEN*X,i*BLOCKLEN);
  }
  //画方块：
  int x,y,k;
  for (i=1; i<=Y; i++){
   for (j=1; j<=X; j++){
    if (tetris[i][j]!=0){
     k = tetris[i][j];
     if (k>COL) k -= COL;
     SelectObject (hdc, brush[k-1]);
     x = (j-1)*BLOCKLEN;
     y = (Y-1-i)*BLOCKLEN;
     Rectangle(hdc,x,y,x+BLOCKLEN,y+BLOCKLEN);
    }
   }
  }
  //显示下一个方块：
  for (i=0; i<=4; i++){
   MoveToEx(hdc,(X+1)*BLOCKLEN,i*BLOCKLEN,NULL);
   LineTo(hdc,(X+5)*BLOCKLEN,i*BLOCKLEN);
  }
  for (i=0; i<=4; i++){
   MoveToEx(hdc,(X+1+i)*BLOCKLEN,0,NULL);
   LineTo(hdc,(X+1+i)*BLOCKLEN,4*BLOCKLEN);
  }
  SelectObject (hdc, brush[1]);
  for (i=0; i<4; i++){
   for (j=0; j<4; j++){
    if (block[next][i*4+j]==1){
     x = (X+1+j)*BLOCKLEN;
     y = i*BLOCKLEN;
     Rectangle(hdc,x,y,x+BLOCKLEN,y+BLOCKLEN);
    }
   }
  }
  //显示分数：
  char szbuf[10];
  TextOut(hdc,(X+1)*BLOCKLEN,6*BLOCKLEN,"Score",strlen("Score"));
  TextOut(hdc,(X+1)*BLOCKLEN,7*BLOCKLEN,szbuf,wsprintf (szbuf,"%d",score));
  //显示关卡：
  TextOut(hdc,(X+1)*BLOCKLEN,9*BLOCKLEN,szbuf,wsprintf(szbuf,"Level:%2d",level));
  EndPaint(hWnd, &ps);
  break;
 case WM_KEYDOWN:
  hdc = GetDC(hWnd);
  if (pause)break;
  else
  switch (wParam){
   case VK_LEFT:
    if (canmove(1)) moveleft();
    InvalidateRect (hWnd, NULL, TRUE) ;
    break;
   case VK_RIGHT:
    if (canmove(2)) moveright();
    InvalidateRect (hWnd, NULL, TRUE) ;
    break;
   case VK_DOWN:
    while (canmove(3)) movedown();
    isbottom();
    InvalidateRect (hWnd, NULL, TRUE) ;
    break;
   case VK_UP:
    turn();
    InvalidateRect (hWnd, NULL, TRUE) ;
    break;
   default:break;
  }
  ReleaseDC (hWnd, hdc);
  break;
 case WM_DESTROY:
  //KillTimer(hWnd,TIMER_PRINT);
  KillTimer(hWnd,TIMER_DOWN);
  PostQuitMessage(0);
  break;
 default:
  return DefWindowProc(hWnd, message, wParam, lParam);
 }
 return 0;
}

 


// “关于”框的消息处理程序。
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
 switch (message)
 {
 case WM_INITDIALOG:
  return TRUE;

 case WM_COMMAND:
  if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  {
   EndDialog(hDlg, LOWORD(wParam));
   return TRUE;
  }
  break;
 }
 return FALSE;
}
/**************************************游戏控制函数******************************************/
//游戏初始化：
int gameinit(void)
{
    int i,j;
    gameover = FALSE;
    for (i=0; i<Y+5; i++)
        for (j=0; j<X+2; j++)
            tetris[i][j] = 0;
    for (j=0; j<X+2; j++){
        tetris[0][j] = 1;
        }
    for (i=0; i<Y+5; i++){
        tetris[i][0] = 1;
        tetris[i][X+1] = 1;
        }
 next = createblock();
    current = next;
    next = createblock();
 score = 0;
 speed = INITSPEED;
 level = 1;
 readonly = FALSE;
    loadblock();
 pause = FALSE;
    return 0;
}
//随机生成方块种类：
int createblock(void)
{
    srand((unsigned)time(NULL));
    return rand()%19;
}
//装载生成的方块：
int loadblock(void)
{
    int i,j;
    int *p;
    p = &block[current][0];
    int *pt;
    pt = &bxy[0][0];
 int color;
 color = rand()%COL;
    for (i=Y+4; i>Y; i--){
        for (j=1; j<5; j++){
            if (*p==1){
               tetris[i][j] = *p+COL+color;
               *pt = j;
               *pt++;
               *pt = i;
               *pt++;
             }
   else tetris[i][j] = 0;
            p++;
        }
    }
    moveright();
    moveright();
    moveright();
    moveright();
    if (!canmove(3))gameover=TRUE;
    return 0;
}

//判断当前方块能否移动，参数代表移动的类型：
int canmove(int how)       /*1 for left, 2 for right, 3 for down*/
{
    if (how==1){
       int i,x,y;
       for (i=0; i<4; i++){
           x = bxy[i][0];
           y = bxy[i][1];
           if (tetris[y][x-1]>0 && tetris[y][x-1]<COL+1)break;
       }
       if (i==4)return TRUE;
       else {
    readonly = FALSE;
    return FALSE;
   };
    }
    else if (how==2){
         int i,x,y;
         for (i=0; i<4; i++){
             x = bxy[i][0];
             y = bxy[i][1];
             if (tetris[y][x+1]>0 && tetris[y][x+1]<COL+1)break;
         }
         if (i==4)return TRUE;
         else {
    readonly = FALSE;
    return FALSE;
   }
    }
    else if (how==3){
         int i,x,y;
         for (i=0; i<4; i++){
             x = bxy[i][0];
             y = bxy[i][1];
             if (tetris[y-1][x]>0 && tetris[y-1][x]<COL+1)break;
         }
         if (i==4)return TRUE;
   else {
    readonly = FALSE;
    return FALSE;
   }
    }
    else exit(3);
}
//左移当前方块：
int moveleft()
{
 if (readonly)return 0;
 else readonly = TRUE;
    int i,j,x,y,tmp,tbx,tby;
    for (i=0; i<3; i++){
        for (j=0; j<3-i; j++){
            if(bxy[j][0]>bxy[j+1][0])
            {tbx=bxy[j][0];bxy[j][0]=bxy[j+1][0];bxy[j+1][0]=tbx;
            tby=bxy[j][1];bxy[j][1]=bxy[j+1][1];bxy[j+1][1]=tby;}
        }
    }
    for (i=0; i<4; i++){
         x = bxy[i][0];
         y = bxy[i][1];
         tmp = tetris[y][x-1];
         tetris[y][x-1] = tetris[y][x];
         tetris[y][x] = tmp;
         bxy[i][0]--;
    }
 readonly = FALSE;
    return 0;
}

//右移当前方块：
int moveright()
{
 if (readonly)return 0;
 else readonly = TRUE;
    int i,j,x,y,tmp,tbx,tby;
    for (i=0; i<3; i++){
        for (j=0; j<3-i; j++){
            if(bxy[j][0]<bxy[j+1][0])
            {tbx=bxy[j][0];bxy[j][0]=bxy[j+1][0];bxy[j+1][0]=tbx;
            tby=bxy[j][1];bxy[j][1]=bxy[j+1][1];bxy[j+1][1]=tby;}
        }
    }
    for (i=0; i<4; i++){
         x = bxy[i][0];
         y = bxy[i][1];
         tmp = tetris[y][x+1];
         tetris[y][x+1] = tetris[y][x];
         tetris[y][x] = tmp;
         bxy[i][0]++;
    }
 readonly = FALSE;
    return 0;
}
//下降当前方块：
int movedown()
{
 if (readonly)return 0;
 else readonly = TRUE;
    int i,j,x,y,tmp,tbx,tby;
    for (i=0; i<3; i++){
        for (j=0; j<3-i; j++){
            if(bxy[j][1]>bxy[j+1][1])
            {tbx=bxy[j][0];bxy[j][0]=bxy[j+1][0];bxy[j+1][0]=tbx;
            tby=bxy[j][1];bxy[j][1]=bxy[j+1][1];bxy[j+1][1]=tby;}
        }
    }
    for (i=0; i<4; i++){
         x = bxy[i][0];
         y = bxy[i][1];
         tmp = tetris[y-1][x];
         tetris[y-1][x] = tetris[y][x];
         tetris[y][x] = tmp;
         bxy[i][1]--;
    }
 readonly = FALSE;
    return 0;
}
//当前方块到达底部时的操作：
int isbottom()
{
 int i,x,y;
 if (!canmove(3)){
       for (i=0; i<4; i++){
           x = bxy[i][0];
           y = bxy[i][1];
           tetris[y][x] -= COL;
    }
 }
 clear();
    current = next;
 next = createblock();
    loadblock();   
 return 0;
}

//旋转当前方块：
int turn()
{
 if (readonly)return 0;
 else readonly = TRUE;
 int i,j,k,minx,miny,tmp,backupbxy[4][2],backupminx,backupminy,x,y;
 //保存当前坐标
 for (i=0; i<4; i++){
  for (j=0; j<2; j++)
   backupbxy[i][j] = bxy[i][j];
 }
 //得到当前方块最左下角坐标
 minx = bxy[0][0];
 miny = bxy[0][1]; 
 for (i=0; i<4; i++){
        if (minx > bxy[i][0]) minx = bxy[i][0];
  if (miny > bxy[i][1]) miny = bxy[i][1];
 }
 
 for (i=0; i<4; i++){
  //换算成相对坐标
  backupbxy[i][0] -= minx;
  backupbxy[i][1] -= miny;
  //坐标旋转
  tmp = backupbxy[i][0];
  backupbxy[i][0] = backupbxy[i][1];
  backupbxy[i][1] = 3-tmp;
 }
 backupminx = backupbxy[0][0];
 backupminy = backupbxy[0][1]; 
 for (i=0; i<4; i++){
        if (backupminx > backupbxy[i][0]) backupminx = backupbxy[i][0];
  if (backupminy > backupbxy[i][1]) backupminy = backupbxy[i][1];
 }
 for(i=0; i<4; i++){
  backupbxy[i][0] -= backupminx;
  backupbxy[i][1] -= backupminy;
 }
 for(i=0; i<4; i++){
  //旋转后的坐标还原到原始位置
  backupbxy[i][0] += minx;
  backupbxy[i][1] += miny;
  //判断旋转后是否出界
  if (backupbxy[i][0]>X || backupbxy[i][0]<1)break;
  if (backupbxy[i][1]>Y+2 || backupbxy[i][1]<1)break;
  //判断是否有障碍物阻挡
  x = backupbxy[i][0];
  y = backupbxy[i][1];
  if (tetris[y][x]>0 && tetris[y][x]<COL+1)break;
 }
 //如果不出界，清除原方块，求出旋转后方块
 tmp = tetris[bxy[0][1]][bxy[0][0]];
 if (i>=4){
  for (k=0; k<4; k++) tetris[bxy[k][1]][bxy[k][0]] = 0;
  for (k=0; k<4; k++) tetris[backupbxy[k][1]][backupbxy[k][0]] = tmp;
  for (j=0; j<4; j++)
   for (k=0; k<2; k++)
    bxy[j][k] = backupbxy[j][k];
 }
 readonly = FALSE;
 return 0;
}

//判断能否消行以及加分
int clear()
{
 int i,j;
 for (i=1; i<=Y; i++){
  for (j=1; j<=X; j++){
   if (tetris[i][j]==0 || tetris[i][j]>COL)break;
        }
  if (j > X){
   downline(i);
   score += 10;
   level = score/SCOREPERLEVEL + 1;
   speed = INITSPEED-TIMELEVEL*level;
  }
 }
 return 0;
}
//从指定行开始，上方的行全部下移一行，参数为指定的行数：
int downline(int line)
{
 int i,j;
 for (i=line; i<Y; i++){
  for (j=1; j<=X; j++){
   if (tetris[i+1][j]<COL+1)tetris[i][j] = tetris[i+1][j];
   else tetris[i][j] = 0;
  }
 }
 clear();
 return 0;
}

///

C语言游戏: 俄罗斯方块（Tetris）@兼谈程序优化方法 [源码+exe下载]
益远的博客
03-10 971
消除重复：如何将程序逻辑与数据分开？ ----俄罗斯方块（Tetris）程序的优化方法 背景提示： 1，数据，是程序设计的根本。 因为任何程序都可以看作是一组数据，和作用于其上的一组操作， 这也是面向对象程序设计中“类”的由来。 对C++来说，这组数据就是类的成员变量，或叫对象； 而作用于其上的一组操作就是成员函数，也称方法。 2，逻辑，是程序设计的核心。 因为任何程序本质上都是基于数据的逻辑产品。 复杂冗长的逻辑没有人喜欢，而要简化逻辑首先就是消除重复； 这就是循环语句的存在价值和使命。 3
C语言实现俄罗斯方块
yulong__li的博客
10-11 2542
看下游戏界面： 不知道怎么介绍，直接上代码： Model.h #pragma once #define FACE_X 20 #define FACE_Y 29 #define WALL 2 #define BOX 1 #define KONG 0 typedef struct Face { int data[FACE_Y][FACE_X + 10]; //1-&g...
将特殊的时间格式转为正常格式2019-07-05T03:56:21.000+0000变为2019-07-05
Bxy_buxiaoyu的博客
07-19 4637
在做前台展示时，时间格式不对2019-07-05T03:56:21.000+0000这种 解决办法： 定义一个方法 function changeTime(date) { var newDate = new Date(date).toJSON(); return new Date(+new Date(newDate) + 8 * 3600 * 1000).to...
C语言版Tetris——俄罗斯方块
锵锵锵锵蒋的博客
02-19 968
此程序包括2个头文件，3个.c文件control.hprint.hcontrol.cmain.cprint.c control.h #ifndef _CONTROL_H_ #define _CONTROL_H_ #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;time.h&amp;gt; #include &amp;lt;
VS2017 简单推箱子游戏
qq_41454682的博客
04-26 841
VS2017 简单推箱子游戏 先为迷宫布局 int migo[11][11] = { {1,1,1,1,1,1,1,1,1,1,1}, {1,0,0,0,0,0,0,0,0,0,1}, {1,0,1,0,1,0,1,0,1,0,1}, {1,0,0,0,0,0,0,0,0,0,1}, {1,0,1,0,1,0,1,0,1,0,1}, {1,0,0,0,0,0,0,0,0,0,1},...
陈广 C# 俄罗斯方块源码
11-29
【标题】：“陈广 C# 俄罗斯方块源码”是一个使用C#编程语言实现的俄罗斯方块游戏的源代码，由陈广开发并已在.NET Framework 2005环境下进行了测试，确保其正常运行。这个项目主要是为了教育和学习目的，让开发者...
俄罗斯方块源程序和流程图
01-17
* 二、此游戏没有版权，可以乱改，反正我也是在学习，谢谢那些无私的网友们，不过 * 请你们下次提交上来的源程序有个说明好不好，看得我头都大了，流程图也没得， * 设计说明也没有，完全看源代码，很费力的...
用C写的俄罗斯方块可以看看
01-28
这是一款使用C语言编写的俄罗斯方块游戏，由网友hoodlum1980编写，并于2008年发布。该游戏代码不到600行，简洁而实用，是学习C语言编程和游戏开发的良好案例。 #### 代码结构概览 该程序使用了标准C库中的多个...
我为什么要写博客？
流楚丶格念的博客
07-13 3403
我为什么要写博客？ 一开始我也不知道的，从19年刚进入大学，当时选择软件工程也不知道是为什么，甚至怎么报的志愿都忘了， 大家对写博客的看法 他日若遂凌云志，敢笑黄巢不丈夫
如何高效的自学编程（新手篇）
wqd_jy的博客
04-19 7532
如何高效的自学编程（新手篇） 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录如何高效的自学编程（新手篇）前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表
Visual C++——《可视化编程技术》课程考核
无限迭代中......
04-08 844
问题描述 工程文件的名字取” 学号_姓名_课内考查”，工程文件中所有文件名均为“学号_姓名_课内考查”（包括.cpp,.rc,.h等文件），否则按照“未完成任务”处理（10分） 显示一个WINDOWS窗口，窗口的标题为“学号_姓名_课内考查”，例如“2018620101_张三_课内考查”，演示录屏时该窗口不能遮挡VC6.0窗口的左上侧的文件列表，否则按未完成任务处理。（20分） 将光标设...
c++ -不允许重复启动- 互斥-乱码问题解决
xie__jin__cheng的博客
03-18 133
概要说明 通过MultiByteToWideChar函数转换 MultiByteToWideChar函数是将多字节转换为宽字节的一个API函数，它的原型如下： int MultiByteToWideChar( UINT CodePage, // code page DWORD dwFlags, // character-type options LPCSTR lpMultiByteStr, // string to map int cbMultiByte...
Visual C++——《可视化编程技术》实验报告——资源的应用
无限迭代中......
04-01 1004
一、实验目的和要求 1、使用API函数编制包含各种资源的Windows应用程序； 2、 实现Windows应用程序对键盘与鼠标的响应。 二、实验内容 1、问题描述： 创建一个菜单，其中有三个菜单项，分别为“文件”、“计算”和“帮助”，其中，“文件”菜单项包含“打开”、“保存”、“画图”、“退出”等菜单选项；“计算”菜单包含“总和”、“方差”、“均方根”等菜单选项；“帮助”菜单项包含...
用C语言编写的 俄罗斯方块小游戏（tetris game）
编码人生——朝阳_tony
06-27 4825
摘要： 还记得当前我们玩过的俄罗斯方块吗 ，在linux系统下编译安装试试,O(∩_∩)O~
fopen 打开文件，处理数据
shinebxy的博客
01-08 3221
1、fopen ： 打开文件或url , 如果的打开失败返回false fopen（filename/url，mode）  这两个参数是必选的，第一个文件名/url，第二个打开的方式 $handle = fopen($filename,'r'); 打开方式常用的有以下几种： r      只读方式打开，将文件指针指向文件头 r+    读写方式打开，将文件指针指向文件头 w    写入...
C语言俄罗斯方块（简易版）
ZXL工作室
05-08 7879
本俄罗斯方块全部用绘图函数实现方块的绘制，没有一点资源，因此源代码很小巧，整个程序编译链接好，也就10K多吧。非常小巧的俄罗斯方块。 设计思想： 1、将游戏区域划分为18行*10列的棋盘，设立一个布尔型的二维数组变量，以表示棋盘上各个地方是否有方块。 2、用4个顶点代表各种不同形状的方块，一旦方块在游戏区域中，就把对应的布尔型二维数组变量置为真，表示该方格已经有方块了。 3、如
C项目实践--俄罗斯方块（2）
weixin_33775572的博客
07-03 2244
在VS中新建win32 Application Proj,选择Empty ，完成TetrisWin项目创建。新建tetris.c和tetris.h两个文件，打开tetris.h文件。 首先要包括的是可能要用到的头文件，那在这里要用到是什么头文件呢？ 本系统是开发一个游戏，那么游戏的话就需要有和用户进行交互的游戏界面，那就需要绘图操作，那么就会用到windows的绘图函数库，所以第一步就是要包括这...
word“域”的使用方法（转）
热门推荐
月夜领域
11-14 2万+
域是WORD中的一种特殊命令，它由花括号、域名（域代码）及选项开关构成。域代码类似于公式，域选项并关是特殊指令，在域中可触发特定的操作。在用WORD处理文档时若能巧妙应用域，会给我们的工作带来极大的方便。特别是制作理科等试卷时，有着公式编辑器不可替代的优点。 用插入域或者Ctrl+F9快捷键启动域输入模式。按F9或者右键选择切换域代码可以显示域代码或显示效果 输入分数：格式为“EQ”空
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值