C++做拼图游戏

一步一步做拼图游戏，C++版首先，我们就要抛弃控制台的黑洞洞的窗口了，我们必须要先创建一个Windows的窗口。创建的方法有很多，不过呢，要先确定你将要使用的编译器，VC6.0，VS2005，VS 2008，VS2010，DEV-C++，Code::Block等等，还有一个C++ Builder和其他的不太一样。我用的是VS2010 Team版，Win7系统。所以我就以VS2010为例子了。其他的也差不多。

一、创建窗口：

1.文件->新建->项目->Win32项目，写上名字，点确定。如图

2.在新窗口中点下一步，直接点完成也可以，直接点完成的就可以跳过第3步。

3.在这个窗口中要选择windows应用程序，不要选空项目，再点确定，如图：

这些完了之后，就会出现Puzzle.cpp文件，里面就是代码。解决方案管理器里会有其他的东西，如图所示：

可以看到有很多文件，双击打开后都有注释写着每个文件的用处，我们目前只用到Pu zzle.cpp，当然，如果你起的是别的名字，就和我的不同了。

现在编译，运行就可以看到一个白色的窗口，里面什么都没有。

然后，我们还要进行一点其他的修改工作：

找到下面的一段代码

Code:

1.BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

2.{

3. HWND hWnd;

4.

5. hInst = hInstance; //

6.

7. hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW & ~WS_SIZ

EBOX & ~WS_MAXIMIZEBOX, //这里修改了，让WS_OVERLAPPEDWINDOW & ~WS_SIZEBOX & ~WS_MAX IMIZEBOX的目的是去掉最大化的按钮，同时禁止修改窗口大小

8. CW_USEDEFAULT, 0, /*CW_USEDEFAULT, 0*/800, 600, /*这里的800和600就是窗

口的大小，我采用的是800*600的，大家自己根据实际情况改*/NULL, NULL, hInstance, NULL);

9.……

10.}

二、制作一些其他需要的资源

现在有窗口了，那么，我们要有其他的资源，比如各种图片，声音，还可以有鼠标指针。

我们先制作图片就行了，声音，鼠标指针以后再说。因为图片资源是必须的，其他的是可选的。

我们需要一张背景图片。

随便找张图片，选个大小，我当然选的是800*600的。

然后打开PS去修改吧，我不教PS了，我改的结果是这样的，里面还有一些坐标要记下来的。如图：

再来一张没坐标的，可以直接下载用。不过因为CSDN的相册空间太小，所以给个地址吧，链接到百度相册，大家见谅。

https://www.360docs.net/doc/9a17543243.html,/yjn43422757/pic/item/b71b2654aeb2c412564e0084. jpg

记住，保存成BMP格式的，因为BMP的读取起来很容易，如果是JPG的，还要自己去写相应的读取函数。

转换的方法就是用画图打开图片，然后选择“文件->另存为->BMP（24位）”

然后，还要一张用来进行游戏的图，也就是要拼的图，这个更简单了，弄张400*400的就行了（因为我的游戏区大小是400*400）。

到现在为止，我们的准备工作已经完成了。下面，就是编写代码的过程了。

三、设计功能

1.定义类

CPuzzleLogic, 用来实现内部逻辑的行为

CPuzzleView, 用来实现视图显示方面的

CPuzzleMain 用来实现主程序，主要是把各部分的联系起来

如果还有其他需要的，以后再定义别的

创建类的时候可以用类向导，不过，VS2008和VS2005里没有，所以用以下方法：先把解决方案管理器调到类视图里，在项目名称上单击鼠标右键，添加，类

选“C++类”，单击“添加”，在新窗口中写上类名，单击“确定”

如上图，再重复添加其他两个类。

在CPuzzleMain类的头文件上面的#pragma once后面加上

#include "PuzzleLogic.h"

#include "PuzzleView.h"

2.给类相应的功能

先在CPuzzleMain类里添加两个成员变量，分别是其他两个类的类型，用来以后引用里面的功能。

添加方法如下图：

在类视图里右键单击类名称，添加，添加变量

选成private可以防止类外访问到它，写上变量类型和变量名称，然后可以写几句注释

以同样的方法再添加另一个变量，当然，你也可以直接在头文件里写上，效果是一样的，只是这样的做法可以自动初始化系统有的类型，否则有时候会出错。

3.添加画图功能

我们设计一个画图的函数，这样的话，以后就不必每次都去写画图函数了

添加函数的方法：在类视图里右键单击类名称，添加，添加函数，参考添加变量的图在新窗口中输入返回类型，函数名，函数的参数，以及注释等等信息。

这样的好处是点击完成的时候，系统会自动添加到头文件中声明，和.cpp文件中的定义部分。

然后写代码吧。

(1)要先在CPuzzleView里加上两个成员变量

private:

HWND m_hWnd; // 保存窗口句柄

HBITMAP m_hBmpBack;//保存背景图片

(2)把前面做好的图片复制到源代码文件夹的res文件夹里，如果没有的话，就自己新

建一个，当然你也可以写别的名字，不过要自己记住，我这里就以res为例子。

(3)添加以下几个函数

Code:

1.// 画图，hBitmap表示指向图片的指针，x,y表示位图显示的横纵坐标，nWidth,nHeight位图

的宽度和高度，srcX,srcY从位图的的哪个位置开始显示

2.void CPuzzleView::DrawPic(HBITMAP hBitmap, int x, int y, int nWidth, int nHe

ight, const int srcX=0, const int srcY=0)

3.{

4. HDC hdcMe

m;

//内存DC

5. HDC hdcScr = GetDC(m_hWnd); //获取屏幕的DC

6. hdcMem = CreateCompatibleDC(hdcScr); //创建兼容屏幕的内存DC

7. SelectObject( hdcMem, hBitmap ); //将图片绑

定内存DC上

8. BitBlt( hdcScr, x, y, nWidth, nHeight, hdcMem, srcX, srcY, SRCCOP

Y ); //将内存DC里的东西画到屏幕上

9. DeleteDC(hdcMe

m); //清除两个D C

10. DeleteDC(hdcScr);

11.}

12.

13.// 初始化图像显示的对象

14.bool CPuzzleView::InitView(HWND hWnd)

15.{

16. m_hWnd = hWnd; //将窗口句柄传进来

17. m_hBmpBack = (HBITMAP)LoadImage(NULL, _T("res\\background.bmp"), IMAG

E_BITMAP, 0, 0, LR_DEFAULTSIZE|LR_LOADFROMFILE);//读取图片文件

18.if(m_hBmpBack == NULL)

19. {

20. MessageBox(NULL, _T("读取背景文件失败"), _T("Error"), MB_OK);

21.return false;

22. }

23. DrawPic(m_hBmpBack, 0, 0, 800, 600);//画背景

24.return true;

25.}

26.

27.// 用于重绘

28.void CPuzzleView::OnPaint(void)

29.{

30. DrawPic(m_hBmpBack, 0, 0, 800, 600);//重绘背景

31.}

在CPuzzleMain类里添加函数

Code:

1.// 执行初始化工作

2.bool CPuzzleMain::InitMain(HWND hWnd)

3.{

4. m_View.InitView(hWnd);

5.return false;

6.}

7.// 用来重绘

8.void CPuzzleMain::OnPaint(void)

9.{

10. m_View.OnPaint();

11.}

12.

然后,在Puzzle.cpp中，也就是系统自动生成的文件里添加全局变量及头文件引用

#include "PuzzleMain.h"

CPuzzleMain g_PuzzleMain;//保存游戏实例

在下面的BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)函数中，return前加上游戏的初始化代码

g_PuzzleMain.InitMain(hWnd);

在消息循环的函数中，找到

Code:

1.LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lPar

am)

2.{

3.…

4.case WM_PAINT:

5. hdc = BeginPaint(hWnd, &ps);

6.// TODO: 在此添加任意绘图代码...

7. g_PuzzleMain.OnPaint();//添加绘图代码

8. EndPaint(hWnd, &ps);

9.break;

10.…

11.}

好了，现在编译并运行程序，就可以显示出来背景了。

简单介绍一下，在OnPaint()里会看到HDC类型的变量，比如

HDC hMem；这是声明了一个内存DC，所谓DC，网上说的是设备描述表（Devi ce Context，DC），设备描述表（Device Context，DC）是一个信息结构体，包含物理输出设备及其驱动程序。在Windows平台下，所有的图形操作都是通过它完成。

不用管他是什么结构体，只要知道用它可以操作图形图像，想显示在显示器里就要创建一个兼容显示设备的DC，然后就可以显示了，比如

Code:

1.HDC hdcMem;

m;

//内存DC

2. HDC hdcScr = GetDC(m_hWnd); //获取屏幕的D

C

3. hdcMem = CreateCompatibleDC(hdcScr); //创建兼容屏幕的内存DC

4. SelectObject( hdcMem, hBitmap ); //将图片绑

定内存DC上

5. BitBlt( hdcScr, x, y, nWidth, nHeight, hdcMem, srcX, srcY, SRCCOP

Y ); //将内存DC里的东西画到屏幕上

这个过程是先创建内存DC，然后获取了屏幕DC，再设置内存DC兼容屏幕DC，其实就是这两个的信息是一致的了，然后把图片绑定到内存DC里，这样，内存DC 里就有了图片，但是，这时还看不到图片，我们最后用BitBlt函数把内存DC里的东西复制到屏幕DC上，这样就能显示出来，我们就看到了。如果还是不明白的话，请上网百度，Google一下，有很多解释的。

Code:

1.case WM_PAINT:

2. hdc = BeginPaint(hWnd, &ps);

3.// TODO: 在此添加任意绘图代码...

4. g_PuzzleMain.OnPaint();//添加绘图代码

5. EndPaint(hWnd, &ps);

6.break;

WM_PAINT是windows应用程序的重绘消息，当收到这个消息的时候，就意味着屏幕要发生变化了，需要重绘，一般的，当你把窗口移到屏幕外，再移回来，就要发生重绘等等，我们在这加上重绘代码，使我们的程序在移动或者被覆盖的时候还能显示回来。

虽然上面我们已经写了很多代码了，也能显示背景了，但是有时候会经常改以前的东西，甚至推翻重做。

下面是读取游戏的要拼的图片了。

首先,我们要确定逻辑保存方式,我采用的是一个一维数组表示。而且为了可以切割成任意块数，所以定义成了一个指针类型。这是在CPuzzleLogic里定义的

Code:

1.int* m_Block; //用来保存当前局面的

2. int m_BlockNum; //保存此局横向要分成多少块

因为拼图是一个正方形的，所以只用了一个表示横向的有多少块的变量

还要进行初始化，在CPuzzleLogic里添加了一个初始化函数，当然现在的函数还做不到真正初始化，只是提供了一种测试方法。

Code:

1.// BlockNum为要切割的方块数,只在横向或纵向的

2.bool CPuzzleLogic::InitLogic(int BlockNum)

3.{

4. m_BlockNum = BlockNum;

5. m_Block = new int[BlockNum*BlockNum];

6.for(int i=0; i

7. {

8.for(int j=0; j

9. {

10. int num = BlockNum - i -1;

11. m_Block[i*BlockNum+j] = num*10+j;

12. }

13. }

14.return true;

15.}

16.

而且，修改了一个初始化的函数，增加了读取其他图片的功能。不仅仅是读取背景图片了

然后就是CPuzzleView类里的内容了。改动较大。请仔细看。

下面还定义了很多必要的变量，主要是表示坐标等等。

Code:

1.// 初始化图像显示的对象

2. bool InitView(HWND hWnd, int BlockNum=3);

3.private:

4.//保存图案

5. HBITMAP m_hBmpGame;

6.//保存小图案

7. HBITMAP m_hBmpGameSmall;

8.//右上角的坐标及大小

9.static const int m_Small_x=560;

10.static const int m_Small_y=70;

11.static const int m_Small_width=200;

12.static const int m_Small_height=200;

13.//图片游戏区的大小及坐标

14.static const int m_Game_x = 70;

15.static const int m_Game_y = 100;

16.static const int m_Game_width = 400;

17.static const int m_Game_height = 400;

18. int m_FrameNum;//表示要分隔的块数（一排的）

19. int* m_Block;//表示当前状态

20. bool m_IsGameStarted;//游戏是否已经开始

21.public:

22.// 读取图像列表(就是拆开图像)

23. bool LoadBMPList(int *Block);

24.// 设置游戏是否已经开始

25.void SetGameStarted(bool bStarted);

然后初始化的函数有所改动，增加了一个参数，里面又读取了其他的几个图片。

这里面也没什么要特别说明的。

Code:

1.#define GETX(x) (x+70)

2.#define GETY(y) (y+100)

3.// 初始化图像显示的对象

4.bool CPuzzleView::InitView(HWND hWnd, int BlockNum)

5.{

6.……

7.//读取图案

8. m_hBmpGame = (HBITMAP)LoadImage(NULL, _T("res\\game.bmp"), IMAGE_BITMA

P, 0, 0, LR_DEFAULTSIZE|LR_LOADFROMFILE);

9.if(m_hBmpBack == NULL) //判断是否读取图片成功

10. {

11. MessageBox(NULL, _T("读取图案文件失败"), _T("Error"), MB_OK);

12.return false;

13. }

14. m_hBmpGameSmall = (HBITMAP)LoadImage(NULL, _T("res\\gamesmall.bmp"), I

MAGE_BITMAP, 0, 0, LR_DEFAULTSIZE|LR_LOADFROMFILE);

15.if(m_hBmpGameSmall == NULL) //判断是否读取图片成功

16. {

17. MessageBox(NULL, _T("读取小图案文件失败"), _T("Error"), MB_OK);

18.return false;

19. }

20. m_FrameNum = BlockNum;

21. m_Block = new int[m_FrameNum*m_FrameNum];//这个就是申请内存空间

22. OnPaint();

23.return true;

24.}

25.

26.下一个是以下两个函数，也没什么特别说明的。

27.

28.// 读取图像列表(就是拆开图像)

29.bool CPuzzleView::LoadBMPList(int *Block)

30.{

31. memcpy(m_Block, Block, sizeof(int)*m_FrameNum*m_FrameNum);

32.//m_Block = Block;

33.//OnPaint();

34.return true;

35.}

36.

37.

38.// 设置游戏是否已经开始

39.void CPuzzleView::SetGameStarted(bool bStarted)

40.{

41. m_IsGameStarted = bStarted;

42. OnPaint();

43.}

最关键的是重绘函数，彻底的更改了，上次的教程里只是为了显示一下背景，而现在要显示的东西多了，就不能再用原来的那个了。先看代码：

Code:

1.// 用于重绘

2.void CPuzzleView::OnPaint(void)

3.{

4. HDC hdcMe

m; //内存DC

5. HDC hdcScr = GetDC(m_hWnd); //获取屏幕的DC

6. hdcMem = CreateCompatibleDC(hdcScr); //创建兼容屏幕的内存DC

7. SelectObject(hdcMem, m_hBmpBack); //绑定背景图片到内存DC

8.//画右上角的小图像

9. HDC hdcSmallMem = CreateCompatibleDC(hdcMem);

10. SelectObject(hdcSmallMem, m_hBmpGameSmall);

11. BitBlt(hdcMem, m_Small_x, m_Small_y, m_Small_width, m_Small_height, hd

cSmallMem, 0, 0, SRCCOPY);

12. DeleteDC(hdcSmallMem);

13.//画主图像

14. HDC hdcGameMem = CreateCompatibleDC(hdcMem);

15. SelectObject(hdcGameMem, m_hBmpGame);

16.if(m_IsGameStarted==true)

17. {

18.for(int i=0; i

19. {

20.for(int j=0; j

21. {

22. int x=j*m_Game_width/m_FrameNum; //目标的X坐标

23. int y=i*m_Game_height/m_FrameNum; //目标的Y坐标

24. int width=m_Game_width/m_FrameNum; //目标的宽度

25. int height=m_Game_height/m_FrameNum; //目标的高度

26. int srcX=m_Block[j+m_FrameNum*i]%10*(m_Game_width/m_Fr

ameNum); //源位置的X坐标

27. int srcY=m_Block[j+m_FrameNum*i]/10*(m_Game_height/m_F

rameNum); //源位置的Y坐标

28. BitBlt(hdcMem, GETX(x), GETY(y), width, height, hdcGam

eMem, srcX, srcY, SRCCOPY);

29. }

30. }

31. }

32.else

33. {

34. BitBlt(hdcMem, m_Game_x, m_Game_y, m_Game_width, m_Game_height, h

dcGameMem, 0, 0, SRCCOPY);

35. }

36. DeleteDC(hdcGameMem);

37.//只有当游戏开始后才画线框

38.if(m_IsGameStarted==true)

39. {

40.//画线框

41. HBRUSH hbrNew = CreateSolidBrush(RGB(0x00, 0x00, 0x00)); //创建

一个黑色画刷，当然可以自己定义成任何颜色的

42. HBRUSH hbrOld = (HBRUSH)SelectObject(hdcMem, hbrNew);//将画刷绑定

到hdcMem内存DC中,并保存旧画刷

43.for(int i=0; i<=m_FrameNum; ++i)

44. {

45. int x=(m_Game_width/m_FrameNum)*(i)-2;//计算坐标位置

46. Rectangle(hdcMem, GETX(x), GETY(0), GETX(x+4), GETY(m_Game_

width));//画纵向的矩形框,每个宽为4像素

47. }

48.for(int i=0; i<=m_FrameNum; ++i)

49. {

50. int y=(m_Game_height/m_FrameNum)*(i)-2;

51. Rectangle(hdcMem, GETX(0), GETY(y), GETX(m_Game_height), GE

TY(y+4));//画横向的矩形框

52. }

53. SelectObject(hdcMem, hbrOld);//将旧画刷重新绑定回内存DC

54. }

55. BitBlt(hdcScr, 0, 0, 800, 600, hdcMem, 0, 0, SRCCOPY);

56. DeleteDC(hdcMe

m); //清除两个DC

57. DeleteDC(hdcScr);

58.}

函数很长，先说一下流程，这个采用的是所谓的“双缓冲”技术。先说说这个“双缓冲”技术，一般的画图的话，就是在屏幕上反复画，而系统画的时候是先清除我们的目标位置，然后再画上去，这种情况如果要画的内容很少，或者不频繁的时候，我们感觉不到什么问题，但是如果在屏幕上画很多东西，比如我们这个，要先画背景，再画右上角的图，再画中间游戏区的很多份图像，如果直接画的话，就会有很大的闪动情况，这个时候，就出现了“双缓冲”技术。

采用“双缓冲”就是先在内存中创建一块区域，使其兼容屏幕，也就是和屏幕一样的，相当于一块画布，我们所有的绘图工作都在这块画布上进行，当画好一张后，直接把整张的画布复制到屏幕上，这样，我们看到的屏幕就只进行了一次重绘工作，画了整个窗口，就不会感觉到闪动了。

大部分代码都有注释，可以看明白，

Code:

1.//画右上角的小图像

2.//先创建兼容内存DC的临时DC

3. HDC hdcSmallMem = CreateCompatibleDC(hdcMem);

4. SelectObject(hdcSmallMem, m_hBmpGameSmall);//绑定图像

5. BitBlt(hdcMem, m_Small_x, m_Small_y, m_Small_width, m_Small_height, hd

cSmallMem, 0, 0, SRCCOPY);//画到内存DC相应的位置

6. DeleteDC(hdcSmallMem);//删除临时DC

就是这样的过程。

最麻烦的就是中间游戏区部分。因为我们要把顺序打乱，所以不能直接显示出来那一整张图，要分块显示。如果分块太多，肯定影响性能，因为循环是平方级的。比如分3块就是循环9次。

来说说这个过程，首先，要在CPuzzleLogic类里对逻辑里进行初始化，然后复制给CPuzzleView类的m_Block，以下就只说CPuzzleView类了。

这个m_Block是int类型的，用十位和个位分别表示纵坐标和横坐标，比如12就是横向第3块，纵向第2块（记住，这些都是从0开始的，所以00是第一块），因此我们最多只能是9*9的分块。

然后就是根据这些数字计算在图片的坐标位置。

因为是顺序从左上角到右下角存储数字，所以根据i,j可以得到对应的在窗口上的坐标位置，根据分的块数，计算出来每块的大小。

然后循环显示出来各个小图。

再然后画上分隔的线框。

因为我们要能看出来一共有多少个框，而实际上框没有什么用，在一次游戏中是一样的，其实画线就可以了，不过为了粗细，我实际上是画的矩形。关于函数的具体用法，随便搜一下就有了，我就不解释了。

Rectangle(hdcMem, GETX(x), GETY(0), GETX(x+4), GETY(m_Game _width));//

GET（X）和GET（Y）是两个宏定义，就是加上了偏移量，这样我们就不用自己每次都去计算坐标了。

在这代码前，你会看到一个绑定画刷的语句。

Code:

1.HBRUSH hbrNew = CreateSolidBrush(RGB(0x00, 0x00, 0x00)); //创建一个黑色画

刷，当然可以自己定义成任何颜色的

2. HBRUSH hbrOld = (HBRUSH)SelectObject(hdcMem, hbrNew);//将画刷绑定

到hdcMem内存DC中,并保存旧画刷

3.……

4.SelectObject(hdcMem, hbrOld);//将旧画刷重新绑定回内存DC

我们通过CreateSolidBrush函数创建了一个画刷，画刷的作用就是在接下来的画图工作中，每次绘图的颜色，里面的参数是一个RGB颜色，想用什么颜色自己设定吧，我写的是16进制的形式，写10进制也没问题的。

创建了之后将其绑定到内存DC中，以后画图的时候就是这个颜色了，等画完图还要把原来的画刷绑定回来。这是个好习惯。

大家会发现我用到了m_IsGameStarted变量，是bool类型的，我用它来表示游戏是否已经开始。因为只有开始的时候才应该把图片打乱，还有一个在CPuzzleL ogic里的m_IsPlaying的bool类型的变量，这个是表示是否在游戏中。

呵呵，这两个变量是不一样的。第一个只表示开始，还是结束，第二个也可以表示，但是最主要的可以表示是否暂停。感觉好乱啊，我也承认。

想想我们的游戏规则，一般的就是开始的时候显示一张完整的图，那个就是我们上面代码里绘制游戏区里的else的工作，并且没有线框，所以在绘制线框前也判断了一次。开始后是打乱顺序，然后少一块，所以可以看出来，绘图工作还是有点问题的，不过，那个将是我们下一步的工作。我们也要反复修改代码，尤其是初学者，不可能一次写出完美的代码。

最后等完成的时候，我们再去做一些优化工作，比如哪些函数需要公有，哪些要改成私有的等等。

今天就先到这里吧，如果仅仅是复制代码，或者下载代码，很简单就能结束，不过，那样就达不到学习的目的了，对不？如果只想要个程序，随便去网上下个拼图，人家做的还更好看。

今天的比较长，大家耐心点，有不明白的地方，欢迎和我讨论。

今天的代码：https://www.360docs.net/doc/9a17543243.html,/source/2700843

今天，就要开始做游戏的主要部分了，如何控制游戏。

4.控制操作

我们的控制就是，先空出一个格子不显示，然后单击到这个空格子的周围的格子的图片时，就移动过去。

为此，我们要先把空格子画出来。昨天我们的图片其实还是完整显示的。要稍微修改一下我们的OnPaint函数的代码了。

先看代码。为了省地方，我就把和昨天一样的地方省略了，用省略号代替。

Code:

1.// 用于重绘

2.void CPuzzleView::OnPaint(void)

3.{

4. HDC hdcMe

m; //内存DC

5. HDC hdcScr = GetDC(m_hWnd); //获取屏幕的DC

6. hdcMem = CreateCompatibleDC(hdcScr); //创建兼容屏幕的内存DC

7.//获取窗口大小

8. RECT rect;

9. GetClientRect(m_hWnd, &rect);

10.//按窗口大小创建兼容位图

11. HBITMAP hTemp= CreateCompatibleBitmap(hdcScr, rect.right, rect.bottom);

12. SelectObject(hdcMem, hTemp); //绑定临时背景到内存DC

13.//创建一个临时背景DC

14. HDC hdcTempBK = CreateCompatibleDC(hdcMem);

15. SelectObject(hdcTempBK, m_hBmpBack);

16. BitBlt(hdcMem, 0, 0, SCRWIDTH, SCRHEIGHT, hdcTempBK, 0, 0, SRCCOPY);//

为内存DC画背景

17. DeleteDC(hdcTempBK);

18.//画右上角的小图像

19.……

20.//画主图像

21. HDC hdcGameMem = CreateCompatibleDC(hdcMem);

22. SelectObject(hdcGameMem, m_hBmpGame);

23.if(m_IsGameStarted==true)

24. {

25.for(int i=0; i

26. {

27.for(int j=0; j

28. {

29.……

30.if(m_Block[j+m_FrameNum*i] == LASTBLOCK)

31. {

32.continue;//略掉最后一块不画

33. }

34.……

35. }

36. }

37. }

38.else

39. {

40. BitBlt(hdcMem, m_Game_x, m_Game_y, m_Game_width, m_Game_height, h

dcGameMem, 0, 0, SRCCOPY);

41. }

42.……

43.}

先看这部分。

Code:

1.//获取窗口大小

2. RECT rect;

3. GetClientRect(m_hWnd, &rect);

4.//按窗口大小创建兼容位图

5. HBITMAP hTemp= CreateCompatibleBitmap(hdcScr, rect.right, rect.bottom);

6. SelectObject(hdcMem, hTemp); //绑定临时背景到内存DC

7.//创建一个临时背景DC

8. HDC hdcTempBK = CreateCompatibleDC(hdcMem);

9. SelectObject(hdcTempBK, m_hBmpBack);

10. BitBlt(hdcMem, 0, 0, SCRWIDTH, SCRHEIGHT, hdcTempBK, 0, 0, SRCCOPY);//

为内存DC画背景

按照昨天的方法，虽然正确显示，但是由于SelectObject(hdcMem, m_hBm pBack); 是绑定到内存DC中的位图，这样，当我们对内存DC进行操作时，实际上就是修改了m_hBmpBack里的内容，最后显示的就是它的，而这个变量是存储我们的背景图的，它一改，就相当于背景改变了，就会发现你想要的空格根本就出不来。

所以，我们先创建了一个兼容屏幕的位图，这个位图我们还没有填充任何东西，如果直接显示，就是黑色的。然后绑定到内存DC中，这样，我们以后更改的就是这个位图，和背景位图没关系了。

但是，我们还要显示背景位图，于是我采用了再创建一个DC，用来把背景显示出来的方法。

if(m_Block[j+m_FrameNum*i] == LASTBLOCK)

{

continue;//略掉最后一块不画

}

然后用这个来判断，是不是最后一个方格，如果是的话，就不要画图了。这样就可以空出来最后一块。

其实今天的主要任务是实现单击命令。单击之后要判断，现在只用图来判断就不太好了，所以今天的主要任务是CPuzzleLogic里的内容。今天的比较抽象，不太好理解，我尽量说得详细些。

Code:

1.// 移动当前点击的，成功移动，返回true,否则返回false

2.bool CPuzzleLogic::MoveBlock(int Pos)

3.{

4.//判断游戏是否在进行中

5.if(m_IsPlaying == false)

6. {

7.return false;

8. }

9.//如果是最后一个，则是空的，所以不能移动

10.if(m_Block[Pos]==LASTBLOCK)

11. {