（游戏编程-03）MFC版俄罗斯方块（奇迹冬瓜）

utral董东东 utral董东东 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 2.3k累计阅读 2.3k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄16年
关注
原创 最新推荐文章于 2026-09-05 09:41:13 发布 2.3k 阅读 AI 写同款· GEO 优化 ›
[原创]MFC实现的俄罗斯方块 用MFC实现的俄罗斯方块,上学期期末复习着无聊的时候做出来的,每天做一点,最后居然顺利做出来.做了之后才发现,要做成这个小游戏,值得考虑的地方还是很多的.想了想就有以下的一些细节,总结起来有以下几点: 1.   关于方块结构的确定,最初考虑的是用4*4的数组来表示一个方块,但这就意味着每个方块会造成远大于自身的存储空间的浪费,而且按照这种思路,方块每切换一次形状,就要对一个4*4的数组数据 阅读详情

由于代码插入错位，对不久前发的博文重新发布

（一）运行图

<1开头动画

<2游戏截图

（二）前言

       大二下学期了,小编学的是软件工程专业.学了大量书本后发现根本没有好的实践,没弄出来什么立体的可感的游戏,于是乎在学校实验室花了3到4天的从早到晚的冥思苦想做出来了这个俄罗斯方块的小游戏.其中查了大量的资料.当立体呈现的时候,小编发现了几个BUG,一是加速下落的键盘不灵(⊙o⊙)…!囧.二是控制左右下的键有时差额(⊙o⊙)…!三是当按动键盘的时候开始和暂停的键有闪烁(⊙o⊙)…!四是暂停后还可以左右移动啊!五是还有一些代码算法有点缺陷!在发放给大量的好友测试后返回的信息还有就是程序开始的过场动画不能移动框架,一移动就要卡,等动画结束就好了(⊙o⊙)…!总之经过大量的测试基本功能就有了,但是做完才发现没有显示下一块方块摸样的窗口(⊙o⊙)…先截图再上代码,再详细解释一些函数的用法.

（三）主要部分代码

// Test_ProgramDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "Test_Program.h"
#include "Test_ProgramDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// 对话框数据
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CTest_ProgramDlg 对话框




CTest_ProgramDlg::CTest_ProgramDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CTest_ProgramDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CTest_ProgramDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_SHOCKWAVEFLASH1, m_flash);
}

BEGIN_MESSAGE_MAP(CTest_ProgramDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
 //   ON_WM_SYSCOMMAND()
//   ON_WM_NCHITTEST()
	//}}AFX_MSG_MAP
	
	ON_BN_CLICKED(IDC_BUTTON2, &CTest_ProgramDlg::OnBnClickedButton2)
	ON_BN_CLICKED(IDC_BUTTON1, &CTest_ProgramDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON4, &CTest_ProgramDlg::OnBnClickedButton4)
END_MESSAGE_MAP()


// CTest_ProgramDlg 消息处理程序

BOOL CTest_ProgramDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	
    //pWnd=GetDlgItem(IDC_SHOCKWAVEFLASH1);
	//pWnd->SetWindowPos(-1,0,0,600,600,NULL);
	// 将“关于...”菜单项添加到系统菜单中。
	// IDM_ABOUTBOX 必须在系统命令范围内。
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);
	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}
	// 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标
	// TODO: 在此添加额外的初始化代码
	//Action();

CreateThread(NULL,0,Move,this,0,NULL);

	f=0;
	m_speed=500;
	mark=0;
	score=0;
	down=0;
    d=0;
    stop=0;

	sq[0].arr[0][0]=0;
	sq[0].arr[0][1]=1;
    sq[0].arr[0][2]=0;
	sq[0].arr[0][3]=0;

	sq[0].arr[1][0]=0;
	sq[0].arr[1][1]=1;
    sq[0].arr[1][2]=0;
	sq[0].arr[1][3]=0;

	sq[0].arr[2][0]=0;
	sq[0].arr[2][1]=1;
    sq[0].arr[2][2]=0;
	sq[0].arr[2][3]=0;

	sq[0].arr[3][0]=0;
	sq[0].arr[3][1]=1;
    sq[0].arr[3][2]=0;
	sq[0].arr[3][3]=0;
    //条状
	sq[1].arr[0][0]=0;
	sq[1].arr[0][1]=1;
    sq[1].arr[0][2]=0;
	sq[1].arr[0][3]=0;
	
	sq[1].arr[1][0]=0;
	sq[1].arr[1][1]=1;
    sq[1].arr[1][2]=0;
	sq[1].arr[1][3]=0;

	sq[1].arr[2][0]=0;
	sq[1].arr[2][1]=1;
    sq[1].arr[2][2]=1;
	sq[1].arr[2][3]=0;

	sq[1].arr[3][0]=0;
	sq[1].arr[3][1]=0;
    sq[1].arr[3][2]=0;
	sq[1].arr[3][3]=0;
	//右倒钩
	sq[2].arr[0][0]=0;
	sq[2].arr[0][1]=0;
    sq[2].arr[0][2]=1;
	sq[2].arr[0][3]=0;
	
	sq[2].arr[1][0]=0;
	sq[2].arr[1][1]=0;
    sq[2].arr[1][2]=1;
	sq[2].arr[1][3]=0;

	sq[2].arr[2][0]=0;
	sq[2].arr[2][1]=1;
    sq[2].arr[2][2]=1;
	sq[2].arr[2][3]=0;

	sq[2].arr[3][0]=0;
	sq[2].arr[3][1]=0;
    sq[2].arr[3][2]=0;
	sq[2].arr[3][3]=0;
	//左倒钩
	sq[3].arr[0][0]=0;
	sq[3].arr[0][1]=0;
    sq[3].arr[0][2]=0;
	sq[3].arr[0][3]=0;
	
	sq[3].arr[1][0]=0;
	sq[3].arr[1][1]=1;
    sq[3].arr[1][2]=1;
	sq[3].arr[1][3]=0;

	sq[3].arr[2][0]=0;
	sq[3].arr[2][1]=1;
    sq[3].arr[2][2]=1;
	sq[3].arr[2][3]=0;

	sq[3].arr[3][0]=0;
	sq[3].arr[3][1]=0;
    sq[3].arr[3][2]=0;
	sq[3].arr[3][3]=0;
	//方形
	sq[4].arr[0][0]=0;
	sq[4].arr[0][1]=1;
    sq[4].arr[0][2]=0;
	sq[4].arr[0][3]=0;
	
	sq[4].arr[1][0]=0;
	sq[4].arr[1][1]=1;
    sq[4].arr[1][2]=1;
	sq[4].arr[1][3]=0;

	sq[4].arr[2][0]=0;
	sq[4].arr[2][1]=0;
    sq[4].arr[2][2]=1;
	sq[4].arr[2][3]=0;

	sq[4].arr[3][0]=0;
	sq[4].arr[3][1]=0;
    sq[4].arr[3][2]=0;
	sq[4].arr[3][3]=0;
	//右Z
	sq[5].arr[0][0]=0;
	sq[5].arr[0][1]=0;
    sq[5].arr[0][2]=1;
	sq[5].arr[0][3]=0;
	
	sq[5].arr[1][0]=0;
	sq[5].arr[1][1]=1;
    sq[5].arr[1][2]=1;
	sq[5].arr[1][3]=0;

	sq[5].arr[2][0]=0;
	sq[5].arr[2][1]=1;
    sq[5].arr[2][2]=0;
	sq[5].arr[2][3]=0;

	sq[5].arr[3][0]=0;
	sq[5].arr[3][1]=0;
    sq[5].arr[3][2]=0;
	sq[5].arr[3][3]=0;
	//左z
	sq[6].arr[0][0]=0;
	sq[6].arr[0][1]=0;
    sq[6].arr[0][2]=0;
	sq[6].arr[0][3]=0;
	
	sq[6].arr[1][0]=0;
	sq[6].arr[1][1]=1;
    sq[6].arr[1][2]=0;
	sq[6].arr[1][3]=0;

	sq[6].arr[2][0]=1;
	sq[6].arr[2][1]=1;
    sq[6].arr[2][2]=1;
	sq[6].arr[2][3]=0;

	sq[6].arr[3][0]=0;
	sq[6].arr[3][1]=0;
    sq[6].arr[3][2]=0;
	sq[6].arr[3][3]=0;
	//飞机形
	
	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CTest_ProgramDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
/*
if (nID == SC_MOVE || nID==0xF012)
return;
else
CDialog::OnSysCommand(nID, lParam);
*/
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CTest_ProgramDlg::OnPaint()
{
	if(1==d)
	{
    CPaintDC dc(this); // 用于绘制的设备上下文				//加载背景位图
    CBitmap bmp;
    bmp.LoadBitmap(IDB_BITMAP1);
    CDC dcMemory;
    dcMemory.CreateCompatibleDC(&dc);//创建内存DC
    CBitmap *pOldBmp = dcMemory.SelectObject(&bmp);
    CRect rect;
    GetClientRect(rect);
    dc.BitBlt(0, 0, rect.Width(), rect.Height(), &dcMemory, 0, 0, SRCCOPY);
    dcMemory.SelectObject(pOldBmp);

    CWnd *pWnd=GetDlgItem(IDC_STATIC_TEST);
    CDC *pControlDC=pWnd->GetDC();
	CBrush br(RGB(0,0,0));//创建背景色笔刷
	
    pControlDC->SelectObject(&br);        
    pWnd->Invalidate();
    pWnd->UpdateWindow();
	for(int i=0;i<360;i+=20)
	{
		for(int j=0;j<300;j+=20)
		{
			pControlDC->Rectangle(j,i,j+20,i+20);
		}
	}
	}
   
	//::AfxMessageBox("版本号1.0\n作者:奇迹冬瓜\n版权所有 翻版必究");
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CTest_ProgramDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}


void CTest_ProgramDlg::OnBnClickedButton2()
{
	
	::exit(1);
	// TODO: 在此添加控件通知处理程序代码
}
void CTest_ProgramDlg::OnBnClickedButton4()
{
	
	  stop+=1;
	// TODO: 在此添加控件通知处理程序代码
}
void CTest_ProgramDlg::OnBnClickedButton1()
{
     // play();
	if(0==f)
	{
		f=1;
		CreateThread(NULL,0,play,this,0,NULL);
	}
	// TODO: 在此添加控件通知处理程序代码
}
void CTest_ProgramDlg::InitBackground(int (*Ba)[15])
{
	for(int i=0;i<18;i++)
	{
		for(int j=0;j<15;j++)
		{
			Ba[i][j]=0;
		}
	}
	//::AfxMessageBox("OK");
}

bool CTest_ProgramDlg::GameOver(int (*Ba)[15])
{
	int flag=0;
	for(int i=0;i<18;i++)
	{
		for(int j=0;j<15;j++)
		{
			if(1==Ba[i][j])
			{
				flag+=1;
				break;
			}
		}
	}
	if(flag>=18)
	{
		//::AfxMessageBox("true");
		return true;
		
	}
	else
	{
		//::AfxMessageBox("flase");
		return false;
		
	}
}

int CTest_ProgramDlg::RandomGenSquare()
{
	srand((unsigned)time(NULL));
	return rand()%7;
	//CString as;
	//as.Format("%d",i);
	//::AfxMessageBox(as);
}

void CTest_ProgramDlg::DrawSquare(Squares s,int (*Ba)[15],CPoint p1,CPoint p2)
{
	int k=0;
	for(int i=p1.y;i<=p2.y;i++,k++)
	{
		for(int j=p1.x,l=0;j<=p2.x;j++,l++)
		{
			if(1==s.arr[k][l]&&0==Ba[i][j])
			{
				Ba[i][j]=1;
			}
		}
	}
}
void CTest_ProgramDlg::DrawBackground(int ID,int (*Ba)[15])
{
	CWnd *pWnd=GetDlgItem(ID);
	CDC *pControlDC=pWnd->GetDC();
   // pWnd->Invalidate();
   // pWnd->UpdateWindow();
	COLORREF clr;
	for(int i=0;i<18;i++)
	{
		for(int j=0;j<15;j++)
		{
			if(0==Ba[i][j])
			{
				clr=RGB(0,0,0);
			}
			else
			{
				clr=RGB(0,255,255);
			}
			CBrush brush(clr);
			pControlDC->SelectObject(&brush);
			pControlDC->Rectangle(j*20,i*20,j*20+20,i*20+20);
			brush.DeleteObject();
		}
	}
	pWnd->ReleaseDC(pControlDC);
}
bool CTest_ProgramDlg::HitBottomJudge(int (*Ba)[15],Squares s,CPoint p1,CPoint p2)
{
	int k=0;
	for(int i=p1.y;i<=p2.y;i++,k++)
	{
		for(int j=p1.x,l=0;j<=p2.x;j++,l++)
		{
			if((1==s.arr[k][l]&&18==i+1)||(1==s.arr[k][l]&&1==Ba[i+1][j]&&1!=s.arr[k+1][l]))
			{
				return true;
			}
		}
	}
	return false;
}

void CTest_ProgramDlg::MoveDown(Squares s,int (*Ba)[15],CPoint *p1,CPoint *p2)
{
	
	for(int i=p1->y;i<=p2->y;i++)
	{
		for(int j=p1->x;j<=p2->x;j++)
		{
			if(1==Ba[i][j])
			{
				Ba[i][j]=0;
			}
		}
	}
	p1->y+=1;
	p2->y+=1;
	if(0==down)
	{
		m_speed=300;
	}
	else
	{
		m_speed=10;
	}
	DrawSquare(s,Ba,*p1,*p2);
	::Sleep(m_speed);
	down=0;
	
}
DWORD WINAPI play(LPVOID lpParam) 
{
	  CTest_ProgramDlg *c=(CTest_ProgramDlg*)lpParam;
     c->score=0;
	 c->InitBackground(c->Background);//初始化背景方块
	for(int i=0;i<18;i++)
	{
		for(int j=0;j<15;j++)
		{
			c->temp[i][j]=0;
		}
	}
	while(!c->GameOver(c->Background))//判断是否游戏结束
	{

		c->i=c->RandomGenSquare();//随机生成方块
		c->p1.x=6;
		c->p1.y=-3;
		c->p2.x=9;
		c->p2.y=0;
		c->Copy(c->Background,c->temp);
		c->DrawSquare(c->sq[c->i],c->Background,c->p1,c->p2);
		c->DrawBackground(IDC_STATIC_TEST,c->Background);
		//c->Copy(c->Background,c->temp);
		//判断方块是否触底
		while(!c->HitBottomJudge(c->Background,c->sq[c->i],c->p1,c->p2))
		{
		       while(c->stop%2)
		       {
                    c->Copy(c->temp,c->Background);
			        c->DrawBackground(IDC_STATIC_TEST,c->Background);
				   ::Sleep(1);
		       }
			c->MoveDown(c->sq[c->i],c->Background,&c->p1,&c->p2);//下移方块一次
			c->Copy(c->temp,c->Background);
			c->DrawBackground(IDC_STATIC_TEST,c->Background);//绘制背景
		}
		c->EliminateSquare();//消除方格
		//c->Copy(c->temp,c->Background);
	   /* for(int i=0;i<18;i++)
	    {
		    for(int j=0;j<15;j++)
		    {
			    c->temp[i][j]=0;
		    }
	    }*/

	    c->Copy(c->Background,c->temp);
		c->DrawBackground(IDC_STATIC_TEST,c->Background);//绘制背景
		//c->InitBackground(c->Background);
		//c->Copy(c->temp,c->Background);
		//::Sleep(10000);
		//c->Copy(c->temp,c->Background);
		//c->Copy(c->Background,c->temp);

	}
	::AfxMessageBox("游戏结束!");
	  c->f=0;
      return 0;
}
DWORD WINAPI Move(LPVOID lpParam)  
{

CTest_ProgramDlg *c=(CTest_ProgramDlg*)lpParam;
//c->Lock();
 CString Type="swf";
  HRSRC res=FindResource (NULL,MAKEINTRESOURCE(IDR_SWF1),Type);
  HGLOBAL gl=LoadResource (NULL,res);  
  //返回指向资源内存的地址的指针
  LPVOID lp=LockResource(gl);
  //保存的临时文件名
  CString filename="search.swf";
  
  HANDLE fp= CreateFile(filename,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,0,NULL);
  DWORD a;
  //sizeofResource 得到资源文件的大小
  if (!WriteFile (fp,lp,SizeofResource (NULL,res),&a,NULL))
  return 1;
  //关闭句柄
  CloseHandle (fp);
  //释放内存
  FreeResource (gl);  
 
  //查找flash文件并加载
  TCHAR strCurDrt[500];
  int nLen = ::GetCurrentDirectory(500,strCurDrt);
  if( strCurDrt[nLen]!='\\' )
  {
  strCurDrt[nLen++] = '\\';
  strCurDrt[nLen] = '\0';
  }
    
  CString strFileName = strCurDrt;
  strFileName += "search.swf";
  c->m_flash.LoadMovie(0, strFileName);
  c->m_flash.Stop();
  c->No();
  return true;
}
void CTest_ProgramDlg::No()
{

	::Sleep(30000);
	CWnd *pWnd=GetDlgItem(IDC_SHOCKWAVEFLASH1);
	pWnd->ShowWindow(SW_HIDE);
    pWnd=GetDlgItem(IDC_STATIC_TEST);
	pWnd->SetWindowPos(NULL,80,110,300,360,NULL);
	
	//pWnd=GetDlgItem(IDD_TEST_PROGRAM_DIALOG);
	//pWnd->EnableWindow(TRUE);
    d=1;
	//WS_POPUP
}
/*
void CTest_ProgramDlg::Lock()
{
CWnd *pWnd=GetDlgItem(IDD_TEST_PROGRAM_DIALOG);
pWnd->EnableWindow(FALSE);
}*/
void CTest_ProgramDlg::Copy(int (*Ba)[15], int (*Ca)[15])
{
	for(int i=0;i<18;i++)
	{
		for(int j=0;j<15;j++)
		{
			if(1==Ba[i][j])
			{
				Ca[i][j]=Ba[i][j];
			}
		}
	}
}
void CTest_ProgramDlg::MoveRight(Squares s, int (*Ba)[15], CPoint *p1, CPoint *p2)
{
	       Copy(temp,Background);
	      for(int i=p1->y;i<=p2->y;i++)
	      {
		        for(int j=p1->x;j<=p2->x;j++)
		        {
			         if(1==Ba[i][j])
			        {
				        Ba[i][j]=0;
			        }
		        }
	      }
		  p1->x+=1;
		  p2->x+=1;
		  Copy(temp,Background);
		  DrawSquare(s,Ba,*p1,*p2);
		 // ::Sleep(10);
		//  Copy(temp,Background);
}
void CTest_ProgramDlg::MoveLeft(Squares s, int (*Ba)[15], CPoint *p1, CPoint *p2)
{
	       Copy(temp,Background);
	      for(int i=p1->y;i<=p2->y;i++)
	      {
		        for(int j=p1->x;j<=p2->x;j++)
		        {
			         if(1==Ba[i][j])
			        {
				        Ba[i][j]=0;
			        }
		        }
	      }
		  p1->x-=1;
		  p2->x-=1;
		  Copy(temp,Background);
		  DrawSquare(s,Ba,*p1,*p2);
		//  Copy(temp,Background);
		 // ::Sleep(10);
}

bool CTest_ProgramDlg::RightJudge(int (*Ba)[15],Squares s,CPoint p1,CPoint p2)
{
    int k=0;
	for(int i=p1.y;i<=p2.y;i++,k++)
	{
		for(int j=p1.x,l=0;j<=p2.x;j++,l++)
		{
			if((1==s.arr[k][l]&&15==j+1)||(1==s.arr[k][l]&&1==Ba[i][j+1]&&1!=s.arr[k][l+1]))
			{
				return true;
			}
		}
	}
	return false;
}
bool CTest_ProgramDlg::LeftJudge(int (*Ba)[15],Squares s,CPoint p1,CPoint p2)
{
    int k=0;
	for(int i=p1.y;i<=p2.y;i++,k++)
	{
		for(int j=p1.x,l=0;j<=p2.x;j++,l++)
		{
			if((1==s.arr[k][l]&&-1==j-1)||(1==s.arr[k][l]&&1==Ba[i][j-1]&&1!=s.arr[k][l-1]))
			{
				return true;
			}
		}
	}
	return false;
}

void CTest_ProgramDlg::EliminateSquare()
{
 	int flag=0,a[18],k=0,te;
	for(int i=0;i<18;i++)
	{
		int markNum=0;
		for(int j=0;j<15;j++)
		{
			if(1==Background[i][j])
			{
				markNum++;
			}
		}
		if(15==markNum)
		{
			a[k++]=i;
			flag++;
			score+=100;
			ShowScores(IDC_STATIC_SCORE,score);
		}
	}
	te=k;
	k=0;
	while(k<te)
	{
		for(int i=a[k];i>0;i--)
		{
			for(int j=0;j<15;j++)
			{
				Background[i][j]=Background[i-1][j];
			}
		}
		k++;
	}
	for(int i=0;i<18;i++)
	{
		for(int j=0;j<15;j++)
		{
			temp[i][j]=0;
		}
	}
	Copy(Background,temp);
/*
	while(flag)
	{
	for(int i=17;i>=1;i--)
	{
		for(int j=0;j<15;j++)
		{
			Background[i][j]=Background[i-1][j];

		}	
	}
	for(int i=0,j=0;j<15;j++)
	{
		Background[i][j]=0;
	}
	flag--;
	//c->EliminateSquare();
	}
*/
	//DrawBackground(IDC_STATIC_TEST,Background);

	//Copy(Background,temp);
	//DrawBackground(IDC_STATIC_TEST,Background);
}

void CTest_ProgramDlg::ShowScores(int ID, long score)
{
	CString as;
	as.Format("%d",score);
	GetDlgItem(ID)->SetWindowText(as);
}

BOOL CTest_ProgramDlg::PreTranslateMessage(MSG* pMsg)
{		      
	if (pMsg-> message == WM_KEYDOWN)
	 {
		 if(pMsg-> wParam== VK_UP)//
		 {
				if(!LeftJudge(Background,sq[CTest_ProgramDlg::i],p1,p2)&&!RightJudge(Background,sq[CTest_ProgramDlg::i],p1,p2)&&!HitBottomJudge(Background,sq[CTest_ProgramDlg::i],p1,p2))
				{
				int temp[4][4];
	            for(int i=0;i<4;i++)
	            {
		              for(int j=0;j<4;j++)
		              {
			             temp[i][j]=sq[CTest_ProgramDlg::i].arr[j][3-i];
		              }
	             }
	             for(int i=0;i<4;i++)
	             {
		           for(int j=0;j<4;j++)
		          {
			          sq[CTest_ProgramDlg::i].arr[i][j]=temp[i][j];
		           }
	             }
	             for(int i=p1.y;i<=p2.y;i++)
	             {
		                for(int j=p1.x;j<=p2.x;j++)
		                {
			                  if(1==Background[i][j])
			                  {
				                    Background[i][j]=0;
			                   }
		                }
	              }
	             DrawSquare(sq[CTest_ProgramDlg::i],Background,p1,p2);
				 Copy(CTest_ProgramDlg::temp,Background);
			
			}
		 }

		  if(pMsg-> wParam== VK_DOWN)//
		  {
			down=1;
		  }
		  if(pMsg-> wParam== VK_LEFT)//
		 {
			 Copy(CTest_ProgramDlg::temp,Background);
			if(!LeftJudge(Background,sq[CTest_ProgramDlg::i],p1,p2))
	         {
              MoveLeft(sq[i],Background,&p1,&p2);
              Copy(CTest_ProgramDlg::temp,Background);
			  DrawBackground(IDC_STATIC_TEST,Background);//绘制背景
			}
		 }
		    if(pMsg-> wParam== VK_RIGHT)//
		 {
			 Copy(CTest_ProgramDlg::temp,Background);
			 if(!RightJudge(Background,sq[CTest_ProgramDlg::i],p1,p2))
			 {
			  MoveRight(sq[i],Background,&p1,&p2);
			  Copy(CTest_ProgramDlg::temp,Background);
			  DrawBackground(IDC_STATIC_TEST,Background);
			 }
		 }

	 }
return CDialog::PreTranslateMessage(pMsg);
}
/*
UINT CTest_ProgramDlg::OnNcHitTest(CPoint point)
{
    int ret = CDialog::OnNcHitTest(point);

    if( HTCAPTION == ret)
        return HTCLIENT;

    return ret;
}
*/
/*
void CTest_ProgramDlg::OnSysCommand(UINT nID, LPARAM lParam)
{

}
*/


 

 

收录于
c++

当前文章被收录于：

c++
30 篇文章 0 人学习
订阅专栏 查看详情
标签
#MFC #VC++ #游戏编程 #俄罗斯方块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
基于MFC框架的俄罗斯方块C++实现教程 俄罗斯方块（Tetris）是一款经典的电子拼图游戏，起源于1984年由苏联程序员阿列克谢·帕基特诺夫开发。这款游戏的特色在于玩家需要将不断下落的各种形状的方块拼凑在一起，尽可能地消除行并获取分数。MFC（Microsoft Foundation Classes）是一个C++库，它为Windows API提供了一套面向对象的封装，使得开发者可以使用更简洁的类来创建Windows应用程序。 阅读详情

相关推荐

MFC实现俄罗斯方块

https://download.youkuaiyun.com/download/kris_paul/11952717 代码在这里，使用VS2019的MFC做的，基于对话框，双缓冲技术还在学习中。

成功的方式只有一个，按自己的方式，度过人生。欢迎共赴知识与乐趣的探索之旅！ 850

VC6.0 MFC 单文档 俄罗斯方块游戏

俄罗斯方块游戏 一、详细步骤 1、新建一个MFC单文档应用程序，如下图所示。 2、新建一个类，如下图所示。 3、添加成员变量并初始化，如下图所示。 4、添加成员函数Draw，并在里面调用画游戏边界和画方块函数（后面会用到），如下图所示。 代码如下： void CRussiaBlock::Draw(CDC *p) { CString str; CFont ft; pDC = p; DrawArea(); DrawBlock(); str.Format("得分：%d 分",m_scor

青哥 2582

完整俄罗斯方块游戏源代码剖析与实践

本文还有配套的精品资源，点击获取 简介：《俄罗斯方块源代码》是针对经典游戏"俄罗斯方块"的编程项目，包含完整的游戏源代码。它对于游戏开发、C++编程和图形用户界面（GUI）设计的学习者来说是宝贵的资源。项目覆盖游戏核心算法、图形界面设计、方块类实现、游戏逻辑编程、用户输入处理、状态管理以及分数系统等关键部分。通过源代码的分析与学习，初学者可以掌握游戏开发的基础流程和C++编...

weixin_35751194的博客 1152

简单的MFC俄罗斯方块

MFC俄罗斯方块说明游戏功能介绍游戏界面游戏内数据如何改变文本的样式插入链接与图片游戏功能介绍生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 说明 这是使用 Visual Studio 2013的MFC单文档 开发的一个 简单的 俄罗斯方块游戏。适合初学者，源码中包含 大量注释 ，附件中包含 XMind思维导图 辅助理解。

Mirrors406的博客 1826

MFC俄罗斯方块源码

经典游戏俄罗斯方块的C代码，不过游戏里面除了有传统的方块游戏之外，更会加入“爆弹方块”等不同的元素，以期令玩家有耳目一新的感觉。游戏气狗三个关键模式，分别为Sprint、Master和Bombliss。

MFC俄罗斯方块源程序(额，这个上传错了，全是目标文件，请下载我上传的另一个资源，对不起)

简单界面,有计分,提示下一个方块的功能. 各个方框颜色不同

俄罗斯方块游戏代码

bool Tetris::Judge(int x, int y, int num) //判定在x, y 所指位置是否可画编号为。void Tetris::ReDraw(int x, int y, int num) //为更新图形的位置清除图形。if (Judge(point[0] + 1, point[1], id)) //在某一位置不能下落的话。void Tetris::Draw(int x, int y, int num) //画图形。

lsy110809的博客 2048

俄罗斯方块基于MFC编程

俄罗斯方块基于MFC编程，叙述详细，对每个函数功能有详细说明

C++实现俄罗斯方块（Windows控制台版）

在油管上看到一个使用C++控制台编写的俄罗斯方块小游戏，200多行，B站上也有相关的讲解视频，非常不错，值得学习。优快云博主，讲解得已经非常详细了，为此我就不赘余了。

ccf19881030的专栏 1338

基于mfc的俄罗斯方块(源代码)

基于mfc的俄罗斯方块小游戏，开发工具vs2012.

MFC 俄罗斯方块有源码（纯参考）

MFC 俄罗斯方块有源码

MFC 实现 俄罗斯方块

 很经典的游戏.简单又让人着迷.今天就用mfc来实现个自己的俄罗斯方块.运行截图如下:看起来还行吧..网上有很多版本的实现代码.但是看了几个都是用一个很大的数组记录这些下落的物体的形状.然后写一个很大的switch case来实现变形.感觉真麻烦.今天提出一个容易的实现方法.下面切入正题思路是这样的:一:随机生成物体二:控制    1.变形        围绕一个方块向

秋城 1万+

MFC俄罗斯方块源程序

我的其他资源都是免费的，是对于c语言初学者的帮助比较大的，其中有单片机，ARM，数据结构，window编程，MFC编程，自己编写的小游戏。

基于MFC的俄罗斯方块小游戏(一)

这是一款基于MFC开发的俄罗斯方块小游戏哦！

HY—Chan 3394

mfc基础项目俄罗斯方块系统的源代码

mfc基础项目俄罗斯方块系统的源代码

MiniMaxH3+ComfyUI本地部署：一键整合包、工作流搭建与报错排查

本地部署视频生成模型时，模型权重、推理框架与自定义节点的匹配是核心挑战。MiniMaxH3作为多模态生成模型，通常依赖ComfyUI这类节点式工作流引擎实现可视化调度。一键整合包将Python环境、PyTorch算子、模型文件预置封装，大幅降低部署门槛，并通过半精度加载、显存碎片回收等机制优化推理速度。在文生视频、图生视频与批量生成场景中，清晰的节点链路和参数调优能力直接影响输出质量与显存占用。针对模型不识别、节点执行失败等高频问题，系统排查命令行日志与模型目录可快速定位故障。本文以MiniMaxH3整合包

weixin_29047545的博客 585

VC++ 实现俄罗斯方块小游戏（附全部源码）

自己实现的俄罗斯方块小游戏，基于MFC实现，VS2017

架构师之路，举步维艰。 643

用Python可视化硅晶体生长：3D图解＜100＞/＜110＞/＜111＞晶向差异

本文通过Python 3D可视化技术，详细解析了硅晶体生长中<100>、<110>、<111>三种关键晶向的差异及其在半导体工业中的应用。从密勒指数转换到原子密度计算，结合交互式3D模型展示不同晶向的原子排列特性，帮助读者深入理解晶向对芯片性能的影响。

weixin_42567752的博客 571

俄罗斯方块 c++ MFC

一、实验实习目的及要求 加强对C++语言的深入理解，达到提高学生分析问题，解决综合问题的能力。要求：分析俄罗斯方块游戏的类及层次图；实现俄罗斯方块游戏的基本功能；实现界面：Windows界面，利用对话框应用程序形式。 二、实验实习设备（环境）及要求（软硬件条件） 设备：PC机 操作系统：Windows 编译软件：Visual Studio 2019 三、实验实习内容简介： 系统应实现的主要功能： 游戏方块移动，游戏方块的碰撞检测，游戏方块旋转，满行消除，分数以及等级计算，开始、结束以及重新开始按钮，游戏方

qq_43527345的博客 3016

三相Vienna整流器过零点电流畸变？试试这个SVPWM调制波补偿技巧

本文针对三相Vienna整流器在电流过零点附近出现的电流畸变问题，提出了一种基于SVPWM调制波补偿的有效解决方案。该方法通过注入零序分量重构占空比，巧妙解决因拓扑约束导致的调制矛盾，在基本不增加计算复杂度的前提下，显著平滑电流波形，降低THD。

weixin_29212867的博客 115

OneNet新版MQTT+OneJSON接入全指南

物联网云平台设备接入是嵌入式系统与云端协同的基础能力，其核心依赖于标准化通信协议与统一数据模型。MQTT作为轻量级发布/订阅协议，凭借低带宽占用和高可靠性，成为边缘设备上云的主流选择；而物模型（Thing Model）则定义了设备能力的数字契约，支撑数据语义化与平台自治管理。OneNet新版强制采用MQTT+OneJSON协议栈，不仅提升数据解析一致性与安全认证强度，更推动开发范式从‘协议适配’转向‘模型驱动’。该架构广泛适用于环境监测、智能表计、工业传感等场景，尤其利好基于ESP8266、STM32等资源

weixin_42599558的博客 362

MFC俄罗斯方块

MFC俄罗斯方块设计报告 第一章项目描述 1.1功能描述 使用MFC设计一款俄罗斯方块。实现方块下落，方块移动，方块叠加，方块变形，消行等功能。 1.2所需技术 MFC双缓冲绘图，方块移动，下落，叠加，变形，消行处理。 第二章总体设计 2.1运行流程 如附录图2-1俄罗斯方块运行流程图所示。 第三章详细设计 3.1CTetrisGame类的成员函数与变量

Have a nice day. 5957

项目管理——14规划绩效域论文套路

规划绩效域论文套路

Flee Elf 1153
上一篇： c语言版数据结构（奇迹冬瓜）-链表实战（1）A=AUB
下一篇： MFC写贪吃蛇主文件代码（奇迹冬瓜）
点赞 4
评论 0
书签 书签 6
utral董东东
utral董东东
博客等级 码龄16年 158粉丝 33原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值