• 【MFC】打砖块小游戏（下）（7）

    任务点：

    1、键盘左右键消息处理；

    2、碰撞检测（与砖块、挡板、上、左、右）；

    3、控制转向；

    程序shix

    解决思路：

    1、左右键消息处理：

    响应 WM_KEYDOWN 消息，移动挡板（如果能够的话，重新绘制窗口即可）

    1. case WM_KEYDOWN:
    2. 		{
    3. 			switch(wParam)
    4. 			{
    5. 			case VK_LEFT:	
    6. 				if(bafflex>=5) 
    7. 				{
    8. 					bafflex-=5;
    9. 					hdc=::GetDC(hWnd);
    10. 					Draw(hdc);
    11. 					::ReleaseDC(hWnd,hdc);
    12. 				}
    13.  
    14. 				break;
    15. 			case VK_RIGHT:
    16. 				if(bafflex+110<=445) 
    17. 				{	
    18. 					bafflex+=5;
    19. 					hdc=::GetDC(hWnd);
    20. 					Draw(hdc);
    21. 					::ReleaseDC(hWnd,hdc);
    22. 				}
    23. 				break;				
    24. 			default:  //其他消息发给windows默认窗口处理函数
    25. 				return (DefWindowProc(hWnd,message,wParam,lParam));					
    26. 			}			
    27. 		}

    2、检测球与砖块的碰撞，通过砖块数组下标，计算砖块位置 ：

    左上（j * 45,i * 20)   右下 （（j +1）* 45,（ i + 1）* 20）

    判断条件：

    bally+5 >= i * 20 && bally+5 <= (i+1) *20 && ballx +5>= j * 45 && ballx+5 <= (j+1) *45;

    另外，也可以反过来用 bally / 20    ballx / 45 计算出当前的（i ,j  ）要注意数组越界！

    砖块碰撞后的处理：

    消除砖块（ 数组中 （i,j) 元素置 0 )  球速水平、垂直 逆转

        brick_array[i][j] = 0;                    cy = -cy;                    cx=-cx;

    3、检测球与窗口边缘（左、右、上）以及挡板（是否接住）的碰撞

    1. bool isBlock()
    2. {
    3. 	if(bally <= 0) cy=-cy; 
    4. 	if(ballx <= 0 || ballx >= 435) cx=-cx;	
    5. 	if(bally + 5 >= baffley)
    6. 	{
    7. 		if(ballx < bafflex  || ballx >  bafflex +111)
    8. 		{
    9. 			return false;
    10. 		}
    11. 		cy =-cy;		
    12. 	}
    13. 	return true;
    14. }

    上、左、 右 分别逆转球的运动方向，最后判断是否接住： 先看球已经掉落到挡板位置，然后判断是否在挡板范围内

    4、球没接住的后续处理：

    ::KillTimer(hWnd,1);    // 停了时钟，然后后续的处理

    5、简单粗暴完成版本代码如下：

    主函数：SDK_3.cpp

    1. // SDK_3.cpp : 定义应用程序的入口点。
    2. //
    3.  
    4. #include "stdafx.h"
    5. #include "SDK_3.h"
    6. #include "SDK3_API.h"
    7. #define MAX_LOADSTRING 100
    8.  
    9. // 全局变量:
    10. HINSTANCE hInst;								// 当前实例
    11. TCHAR szTitle[MAX_LOADSTRING];					// 标题栏文本
    12. TCHAR szWindowClass[MAX_LOADSTRING];			// 主窗口类名
    13.  
    14. // 此代码模块中包含的函数的前向声明:
    15. ATOM				MyRegisterClass(HINSTANCE hInstance);
    16. BOOL				InitInstance(HINSTANCE, int);
    17. LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
    18. INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
    19.  
    20. extern int bafflex;  //外部引用全局变量
    21. int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
    22.                      _In_opt_ HINSTANCE hPrevInstance,
    23.                      _In_ LPTSTR    lpCmdLine,
    24.                      _In_ int       nCmdShow)
    25. {
    26. 	UNREFERENCED_PARAMETER(hPrevInstance);
    27. 	UNREFERENCED_PARAMETER(lpCmdLine);
    28.  
    29.  	// TODO: 在此放置代码。
    30. 	MSG msg;
    31. 	HACCEL hAccelTable;
    32.  
    33. 	// 初始化全局字符串
    34. 	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    35. 	LoadString(hInstance, IDC_SDK_3, szWindowClass, MAX_LOADSTRING);
    36. 	MyRegisterClass(hInstance);
    37.  
    38. 	// 执行应用程序初始化:
    39. 	if (!InitInstance (hInstance, nCmdShow))
    40. 	{
    41. 		return FALSE;
    42. 	}
    43.  
    44. 	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SDK_3));
    45.  
    46. 	// 主消息循环:
    47. 	while (GetMessage(&msg, NULL, 0, 0))
    48. 	{
    49. 		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
    50. 		{
    51. 			TranslateMessage(&msg);
    52. 			DispatchMessage(&msg);
    53. 		}
    54. 	}
    55.  
    56. 	return (int) msg.wParam;
    57. }
    58. //
    59. //  函数: MyRegisterClass()
    60. //
    61. //  目的: 注册窗口类。
    62. //
    63. ATOM MyRegisterClass(HINSTANCE hInstance)
    64. {
    65. 	WNDCLASSEX wcex;
    66.  
    67. 	wcex.cbSize = sizeof(WNDCLASSEX);
    68.  
    69. 	wcex.style			= CS_HREDRAW | CS_VREDRAW;
    70. 	wcex.lpfnWndProc	= WndProc;
    71. 	wcex.cbClsExtra		= 0;
    72. 	wcex.cbWndExtra		= 0;
    73. 	wcex.hInstance		= hInstance;
    74. 	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SDK_3));
    75. 	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
    76. 	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
    77. 	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_SDK_3);
    78. 	wcex.lpszClassName	= szWindowClass;
    79. 	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    80.  
    81. 	return RegisterClassEx(&wcex);
    82. }
    83.  
    84. //
    85. //   函数: InitInstance(HINSTANCE, int)
    86. //
    87. //   目的: 保存实例句柄并创建主窗口
    88. //
    89. //   注释:
    90. //
    91. //        在此函数中，我们在全局变量中保存实例句柄并
    92. //        创建和显示主程序窗口。
    93. //
    94. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
    95. {
    96.    HWND hWnd;
    97.  
    98.    hInst = hInstance; // 将实例句柄存储在全局变量中
    99.  
    100.    hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
    101.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
    102.  
    103.    if (!hWnd)
    104.    {
    105.       return FALSE;
    106.    }
    107.  
    108.    ShowWindow(hWnd, nCmdShow);
    109.    UpdateWindow(hWnd);
    110.  
    111.    return TRUE;
    112. }
    113.  
    114. //
    115. //  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
    116. //
    117. //  目的: 处理主窗口的消息。
    118. //
    119. //  WM_COMMAND	- 处理应用程序菜单
    120. //  WM_PAINT	- 绘制主窗口
    121. //  WM_DESTROY	- 发送退出消息并返回
    122. //
    123. //
    124. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    125. {
    126. 	int wmId, wmEvent;
    127. 	PAINTSTRUCT ps;
    128. 	HDC hdc;
    129.  
    130. 	switch (message)
    131. 	{	
    132. 	case WM_CREATE:
    133. 		Init(hWnd);
    134. 		break;
    135. 	case WM_KEYDOWN:
    136. 		{
    137. 			switch(wParam)
    138. 			{
    139. 			case VK_LEFT:	
    140. 				if(bafflex>=5) 
    141. 				{
    142. 					bafflex-=5;
    143. 					hdc=::GetDC(hWnd);
    144. 					Draw(hdc);
    145. 					::ReleaseDC(hWnd,hdc);
    146. 				}
    147.  
    148. 				break;
    149. 			case VK_RIGHT:
    150. 				if(bafflex+110<=445) 
    151. 				{	
    152. 					bafflex+=5;
    153. 					hdc=::GetDC(hWnd);
    154. 					Draw(hdc);
    155. 					::ReleaseDC(hWnd,hdc);
    156. 				}
    157. 				break;				
    158. 			default:  //其他消息发给windows默认窗口处理函数
    159. 				return (DefWindowProc(hWnd,message,wParam,lParam));					
    160. 			}			
    161. 		}
    162. 	case WM_COMMAND:
    163. 		wmId    = LOWORD(wParam);
    164. 		wmEvent = HIWORD(wParam);
    165. 		// 分析菜单选择:
    166. 		switch (wmId)
    167. 		{
    168. 		case IDC_START:
    169. 			::SetTimer(hWnd,1,10,TimerProc);
    170. 			break;
    171. 		case IDM_ABOUT:
    172. 			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
    173. 			break;
    174. 		case IDM_EXIT:
    175. 			DestroyWindow(hWnd);
    176. 			break;
    177. 		
    178. 		default:
    179. 			return DefWindowProc(hWnd, message, wParam, lParam);
    180. 		}
    181. 		break;
    182. 	case WM_PAINT:
    183. 		hdc = BeginPaint(hWnd, &ps);
    184. 		// TODO: 在此添加任意绘图代码...
    185. 		Draw(hdc);
    186. 		EndPaint(hWnd, &ps);
    187. 		break;
    188. 	case WM_DESTROY:
    189. 		PostQuitMessage(0);
    190. 		break;
    191. 	default:
    192. 		return DefWindowProc(hWnd, message, wParam, lParam);
    193. 	}
    194. 	return 0;
    195. }
    196.  
    197. // “关于”框的消息处理程序。
    198. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
    199. {
    200. 	UNREFERENCED_PARAMETER(lParam);
    201. 	switch (message)
    202. 	{
    203. 	case WM_INITDIALOG:
    204. 		return (INT_PTR)TRUE;
    205.  
    206. 	case WM_COMMAND:
    207. 		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
    208. 		{
    209. 			EndDialog(hDlg, LOWORD(wParam));
    210. 			return (INT_PTR)TRUE;
    211. 		}
    212. 		break;
    213. 	}
    214. 	return (INT_PTR)FALSE;
    215. }

    自定义的API头文件：SDK3_API.h

    1. #pragma once
    2. void Init(HWND hWnd);
    3. void Draw(HDC hdc );
    4. void WINAPI TimerProc(HWND, UINT, UINT, DWORD);
    5. bool isHit(int i,int j);
    6. bool isBlock();
    7. void Check();
    8. void MoveBaffle(int x);

    SDK3_API.cpp

    1. #include "stdafx.h"
    2. #include "SDK_3.h"
    3. #include "resource.h"
    4. #include "SDK3_API.h"
    5. extern HINSTANCE hInst;
    6. BYTE brick_array[4][10]={
    7. 	{0,1,1,1,1,1,1,1,1,0},
    8. 	{0,0,1,1,1,1,1,1,0,0},
    9. 	{0,0,0,1,1,1,1,0,0,0},
    10. 	{0,0,0,0,1,1,0,0,0,0}	
    11. };
    12. HBITMAP ball,brick,baffle,tempBitmap;
    13. HDC hMemDC,hTempDC;
    14. int ballx=225,bally=420,bafflex=170,baffley=430,cx=2,cy=-2;
    15. void Init(HWND hWnd)
    16. {
    17. 	baffle = ::LoadBitmap(hInst,MAKEINTRESOURCE(IDB_BITMAP1));
    18. 	ball = ::LoadBitmap(hInst,MAKEINTRESOURCE(IDB_BITMAP2));
    19.     brick = ::LoadBitmap(hInst,MAKEINTRESOURCE(IDB_BITMAP3));
    20.    
    21. 	::SetWindowPos(hWnd,
    22. 		NULL,
    23. 		(::GetSystemMetrics(SM_CXFULLSCREEN) - 450)/2,
    24. 		(::GetSystemMetrics(SM_CYFULLSCREEN) - 450)/2,
    25. 		450,
    26. 		500,
    27. 		SWP_NOZORDER);	
    28. 	HDC hdc = ::GetDC(hWnd);
    29. 	hMemDC = ::CreateCompatibleDC(hdc);
    30. 	hTempDC=::CreateCompatibleDC(hdc);
    31. 	tempBitmap = ::CreateCompatibleBitmap(hdc,450,500);
    32. 	::SelectObject(hTempDC,tempBitmap);
    33. 	
    34. 	::ReleaseDC(hWnd,hdc);
    35. }
    36. void Draw(HDC hdc )
    37. {
    38. 	int i,j;	
    39. 	::PatBlt(hTempDC,0,0,450,500,WHITENESS);
    40.     ::SelectObject(hMemDC,brick);
    41. 	for(i = 0; i < 4; i++)
    42. 	{
    43. 		for(j = 0; j < 10; j++)
    44. 		{
    45. 			if(brick_array[i][j] == 1)
    46. 			{
    47. 				::BitBlt(hTempDC,j * 45,i * 20,45,20,hMemDC,0,0,SRCCOPY);
    48. 			}
    49. 		}
    50. 	}		
    51. 	::SelectObject(hMemDC,ball);
    52. 	::BitBlt(hTempDC,ballx,bally,10,10,hMemDC,0,0,SRCCOPY);
    53. 	::SelectObject(hMemDC,baffle);
    54. 	::BitBlt(hTempDC,bafflex,baffley,111,10,hMemDC,0,0,SRCCOPY);  
    55. 	::BitBlt(hdc,0,0,450,500,hTempDC,0,0,SRCCOPY);  
    56. }
    57. void WINAPI TimerProc(HWND hWnd, UINT nMsg,UINT nTimerid,DWORD dwTime)
    58. {
    59. 	if(nTimerid ==1)
    60. 	{
    61. 		ballx+=cx;
    62. 		bally+=cy;
    63. 		Check();
    64. 		if(!isBlock())
    65. 		{
    66. 			::KillTimer(hWnd,1);
    67. 			return;
    68. 		}
    69. 		HDC hdc=::GetDC(hWnd);
    70. 		Draw(hdc);
    71. 		::ReleaseDC(hWnd,hdc);
    72. 	}
    73. }
    74. bool isHit(int i,int j)
    75. {
    76. 	return bally+5 >= i * 20 && bally+5 <= (i+1) *20 && ballx +5>= j * 45 && ballx+5 <= (j+1) *45;
    77. }
    78. bool isBlock()
    79. {
    80. 	if(bally <= 0) cy=-cy;
    81. 	if(ballx <= 0 || ballx >= 435) cx=-cx;	
    82. 	if(bally + 5 >= baffley)
    83. 	{
    84. 		if(ballx < bafflex  || ballx >  bafflex +111)
    85. 		{
    86. 			return false;
    87. 		}
    88. 		cy =-cy;		
    89. 	}
    90. 	return true;
    91. }
    92. void Check()
    93. {
    94. 	int i,j;	
    95. 	for(i = 0; i < 4; i++)
    96. 	{
    97. 		for(j = 0; j < 10; j++)
    98. 		{
    99. 			if(brick_array[i][j] == 1)
    100. 			{
    101. 				if(isHit(i,j))
    102. 				{
    103. 					brick_array[i][j] = 0;
    104. 					cy = -cy;
    105. 					cx=-cx;
    106. 				}
    107. 			}
    108. 		}
    109. 	}
    110. }

    挡板图片 （111 * 10 ）

     球图片（10*10）

    砖块图片（45 *20）

     

     以上素材可以利用画图工具来完成，如修改尺寸，则需要调整代码中很多数值（窗口大小等等）。

    后记：

    1、本程序为初学Windows C SDK 窗口程序设计 做的一个比较 “粗糙” 的 小游戏，初衷是快速了解窗口程序设计的流程，以及消除对窗口编程的 “恐惧”，所以，很多 细节 都以舍弃，也写了很多很不规划的代码；

    2、从以上的例子可以看出，窗口编程急需解决的问题是 “在哪里写代码” （通过消息处理来确定），“怎么写代码”（熟悉窗口元素的处理，利用以前学的编程逻辑，解决实际问题）；

    3、打砖块游戏的后续处理：如何重新开始游戏、如何设置游戏难度、如何更精细化处理游戏碰撞等等，都可以深入去处理一下。

     

  • 相关阅读:
    【Spring-5.3】AbstractAutowireCapableBeanFactory#initializeBean实现Bean的初始化
    2246: 【区赛】【宁波32届小学生】最佳交换
    自动化工具-文件清单对比
    二维二硫化钼纳米片负载纳米银复合材料|二硫化钼碳纳米管复合材料|纳米金/磁性纳米颗粒修饰二硫化钼纳米片
    【Vue 开发实战】基础篇 # 14：template和JSX的对比以及它们的本质
    Spring注解开发和XML开发
    【JavaScript】JS引擎中执行上下文如何顺序执行代码
    JVM源码剖析之线程的创建过程
    Mybatis动态xml中sql语句拼接参数#和$使用
    js直接操作数据库会怎么样
  • 原文地址：https://blog.csdn.net/yixiaobo2001/article/details/127885928