深圳幻海软件技术有限公司 欢迎您！
更多

Visual C++实现推箱子游戏的核心算法设计与实现（附源码和和资源）

2023-04-14

int case pdc
需要源码和资源请点赞关注收藏后评论区留言私信~~~在前面的博客中已经讲解了推箱子游戏的菜单和各种对话框的实现，下面对推箱子游戏的核心算法设计和实现进行讲解一、地图文件读取模块的设计与实现地图文件读取模块，主要负责将地图文件进行读取，并把相应的文件数据转换成地图显示出来，其设计步骤如下1：读取当前文件

需要源码和资源请点赞关注收藏后评论区留言私信~~~

在前面的博客中已经讲解了推箱子游戏的菜单和各种对话框的实现，下面对推箱子游戏的核心算法设计和实现进行讲解

一、地图文件读取模块的设计与实现

地图文件读取模块，主要负责将地图文件进行读取，并把相应的文件数据转换成地图显示出来，其设计步骤如下

1：读取当前文件夹中的地图文件

2：判断当前选择关口是否在文件中存在

3：如果存在则把当前关口的地图信息放置到地图数组中

其实现代码如下

  1. void CBoxManDlg::loadMap(int iMissionNum)
  2. {
  3.     CString str;
  4.     str.Format("[%d]", iMissionNum);
  6. FILE *pFile = fopen("map.txt", "rb");
  7. if (pFile == NULL)
  8.         return;
  10.     char cTmp[20];
  11.     fgets(cTmp, 20, pFile);
  12.     while (strncmp(cTmp, str, 3) != 0)
  13.     {
  14.         fgets(cTmp, 20, pFile);
  15.     }
  17.     for (int i = 0; i < 14; i++)
  18.         fgets(m_cMap[i], 20, pFile);
  20.     fclose(pFile);
  21. }

二、地图绘制模块的设计与实现

绘制地图模块主要负责将地图数组中的数据绘制成地图图像，其设计分为如下几个步骤

1：根据要求，实现不同类型格子的绘制函数，地图数组以及地图文件中各个字符代表的意思如下

2：读取地图数据，根据不同的数据调用不同的绘图函数

代码如下

  1. void CBoxManDlg::drawMap(CDC *pDC)
  2. {
  3.     int i, j, x, y;
  4.     for (i = 0; i < 14; i++)
  5.     {
  6.         for (j = 0; j < 16; j++)
  7.         {
  8. x = j * 20;
  9.             y = i * 20;
  10.             switch (m_cMap[i][j])
  11.             {
  12.             case MAP_BACK://0
  13.                 drawBack(x, y, pDC);
  14.                 break;
  15.             case MAP_WHITEWALL://1
  16.                 drawWhiteWall(x, y, pDC);
  17.                 break;
  18.             case MAP_BLUEWALL://2
  19.                 drawBlueWall(x, y, pDC);
  20.                 break;
  21.             case MAP_BALL://3
  22.                 drawBall(x, y, pDC);
  23.                 break;
  24.             case MAP_BOX://4
  25.                 drawBox(x, y, pDC);
  26.                 break;
  27.             case MAP_REDBOX://5
  28.                 drawRedBox(x, y, pDC);
  29.                 break;
  30.             case MAP_MAN://6
  31.                 drawMan(x, y, pDC);
  32.                 break;
  33.             case MAP_MANBALL://7
  34.                 drawManBall(x, y, pDC);
  35.                 break;
  36.             }
  37.         }
  38.     }
  39.  
  40. COLORREF crText = pDC->GetTextColor();
  41. COLORREF crBack = pDC->GetBkColor();
  42. pDC->SetTextColor(RGB(255, 0, 0));
  43. pDC->SetBkColor(RGB(255, 255, 255));
  44. CString str;
  45. str.Format("当前等级: %02d", g_level);
  46.     pDC->TextOut(330, 50, str);
  47. str.Format("已走步数: %03d", passtime);
  48. pDC->TextOut(330, 100, str);
  49. }
  50. void CBoxManDlg::drawBack(int x, int y, CDC *pDC)
  51. {
  52.     COLORREF clr = RGB(0, 0, 0);
  53.     pDC->FillSolidRect(x, y, 20, 20, clr);
  54. }
  55.  
  56. void CBoxManDlg::drawWhiteWall(int x, int y, CDC *pDC)
  57. {
  58.     COLORREF clr1 = RGB(255, 255, 255);
  59.     COLORREF clr2 = RGB(48, 48, 48);
  60.     COLORREF clr3 = RGB(192, 192, 192);
  61.     pDC->FillSolidRect(x, y, 19, 19, clr1);
  62.     pDC->FillSolidRect(x + 1, y + 1, 19, 19, clr2);
  63.     pDC->FillSolidRect(x + 1, y + 1, 18, 18, clr3);
  64.     pDC->MoveTo(x, y + 10);
  65.     pDC->LineTo(x + 20, y + 10);
  66.     pDC->MoveTo(x + 10, y + 10);
  67.     pDC->LineTo(x + 10, y + 20);
  68. }
  69.  
  70. void CBoxManDlg::drawBlueWall(int x, int y, CDC *pDC)
  71. {
  72.     COLORREF clr = RGB(0, 0, 255);
  73.     pDC->FillSolidRect(x, y, 20, 20, clr);
  74.     pDC->MoveTo(x, y + 10);
  75.     pDC->LineTo(x + 20, y + 10);
  76.     pDC->MoveTo(x + 10, y + 10);
  77.     pDC->LineTo(x + 10, y + 20);
  78. }
  79.  
  80. void CBoxManDlg::drawBall(int x, int y, CDC *pDC)
  81. {
  82.     COLORREF clr = RGB(0, 0, 255);
  83.     pDC->FillSolidRect(x, y, 20, 20, clr);
  84.     pDC->MoveTo(x, y + 10);
  85.     pDC->LineTo(x + 20, y + 10);
  86.     pDC->MoveTo(x + 10, y + 10);
  87.     pDC->LineTo(x + 10, y + 20);
  88.     pDC->Ellipse(x, y, x + 20, y + 20);
  89.     pDC->Ellipse(x + 5, y + 5, x + 15, y + 15);
  90. }
  91.  
  92. void CBoxManDlg::drawBox(int x, int y, CDC *pDC)
  93. {
  94.     COLORREF clr = RGB(255, 255, 0);
  95.     pDC->FillSolidRect(x, y, 20, 20, clr);
  96.     COLORREF clr2 = RGB(255, 192, 0);
  97.     pDC->FillSolidRect(x + 2, y + 2, 16, 16, clr2);
  98.     COLORREF clr3 = RGB(0, 0, 0);
  99.     pDC->SetPixel(x + 3, y + 3, clr3);
  100.     pDC->SetPixel(x + 17, y + 3, clr3);
  101.     pDC->SetPixel(x + 3, y + 17, clr3);
  102.     pDC->SetPixel(x + 17, y + 17, clr3);
  103. }
  104.  
  105. void CBoxManDlg::drawRedBox(int x, int y, CDC *pDC)
  106. {
  107.     COLORREF clr = RGB(255, 255, 0);
  108.     pDC->FillSolidRect(x, y, 20, 20, clr);
  109.     COLORREF clr2 = RGB(255, 0, 0);
  110.     pDC->FillSolidRect(x + 2, y + 2, 16, 16, clr2);
  111.     COLORREF clr3 = RGB(0, 0, 0);
  112.     pDC->SetPixel(x + 3, y + 3, clr3);
  113.     pDC->SetPixel(x + 17, y + 3, clr3);
  114.     pDC->SetPixel(x + 3, y + 17, clr3);
  115.     pDC->SetPixel(x + 17, y + 17, clr3);
  116. }
  117.  
  118. void CBoxManDlg::drawMan(int x, int y, CDC *pDC)
  119. {
  120.     COLORREF clr = RGB(0, 0, 255);                   //蓝色墙
  121.     pDC->FillSolidRect(x, y, 20, 20, clr);
  122.     pDC->MoveTo(x, y + 10);
  123.     pDC->LineTo(x + 20, y + 10);
  124.     pDC->MoveTo(x + 10, y + 10);
  125.     pDC->LineTo(x + 10, y + 20);
  127.     pDC->Ellipse(x + 6, y + 2, x + 14, y + 10);      //人头
  129.     pDC->MoveTo(x + 2, y + 11);                      //人手
  130.     pDC->LineTo(x + 18, y + 11);
  132.     pDC->MoveTo(x + 10, y + 10);                     //人身体
  133.     pDC->LineTo(x + 10, y + 12);
  135.     pDC->MoveTo(x + 2, y + 20);                      //人脚
  136.     pDC->LineTo(x + 10, y + 12);
  137.     pDC->LineTo(x + 18, y +20);
  138. }
  139.  
  140. void CBoxManDlg::drawManBall(int x, int y, CDC *pDC)
  141. {
  142.     COLORREF clr = RGB(0, 0, 255);                   //球
  143.     pDC->FillSolidRect(x, y, 20, 20, clr);
  144.     pDC->MoveTo(x, y + 10);
  145.     pDC->LineTo(x + 20, y + 10);
  146.     pDC->MoveTo(x + 10, y + 10);
  147.     pDC->LineTo(x + 10, y + 20);
  148.     pDC->Ellipse(x, y, x + 20, y + 20);
  149.     pDC->Ellipse(x + 5, y + 5, x + 15, y + 15);
  151.     pDC->Ellipse(x + 6, y + 2, x + 14, y + 10);      //人头
  153.     pDC->MoveTo(x + 2, y + 11);                      //人手
  154.     pDC->LineTo(x + 18, y + 11);
  156.     pDC->MoveTo(x + 10, y + 10);                     //人身体
  157.     pDC->LineTo(x + 10, y + 12);
  159.     pDC->MoveTo(x + 2, y + 20);                      //人脚
  160.     pDC->LineTo(x + 10, y + 12);
  161.     pDC->LineTo(x + 18, y +20);
  162. }

三、键盘操作模块的设计与实现

键盘操作模块主要负责接收玩家键盘输入并进行箱子移动等处理，其设计比较简单，只需要通过如下几步即可实现

1：通过截获当前窗口键盘按下消息来判断玩家按下的按键

2：根据玩家标下的按键把主角的相关坐标进行加减，

3：增加后的数据与地图数组中的数据进行比较，只要不是白墙就可以移动，如果是箱子还需要将箱子的坐标进行移动

4：但要注意，要判断箱子移动后的坐标是否可以移动

代码如下

  1. BOOL CBoxManDlg::PreTranslateMessage(MSG* pMsg) 
  2. {
  3. if(pMsg->message == WM_KEYDOWN) 
  4. { 
  5. updateMap(pMsg->wParam);
  6. Invalidate(false);
  7. if (isFinish())
  8. {
  9. AfxMessageBox("您获得胜利,将进入下一关!");
  10. g_level = g_level +1;
  11. if (g_level > g_maxlevel)
  12. g_level = 1;
  13. GameStart();
  14.  
  15. }
  16. }
  17. return CDialog::PreTranslateMessage(pMsg);
  18. }
  19. void CBoxManDlg::updateMap(UINT nChar)
  20. {
  21. int x1, y1, x2, y2, x3, y3;
  23.     x1 = m_ptManPosition.x;
  24.     y1 = m_ptManPosition.y;
  26.     switch (nChar)
  27.     {
  28.     case VK_UP:
  29.         x2 = x1;
  30.         y2 = y1 - 1;
  31.         x3 = x1;
  32.         y3 = y1 - 2;
  33.         ReDrawMap(x1, y1, x2, y2, x3, y3);
  34.         break;
  35.     case VK_DOWN:
  36.         x2 = x1;
  37.         y2 = y1 + 1;
  38.         x3 = x1;
  39.         y3 = y1 + 2;
  40.         ReDrawMap(x1, y1, x2, y2, x3, y3);
  41.         break;
  42.     case VK_LEFT:
  43.         x2 = x1 - 1;
  44.         y2 = y1;
  45.         x3 = x1 - 2;
  46.         y3 = y1;
  47.         ReDrawMap(x1, y1, x2, y2, x3, y3);
  48.         break;
  49.     case VK_RIGHT:
  50.         x2 = x1 + 1;
  51.         y2 = y1;
  52.         x3 = x1 + 2;
  53.         y3 = y1;
  54.         ReDrawMap(x1, y1, x2, y2, x3, y3);
  55.         break;
  56. default:
  57. break;
  58.     }
  59. }
  60.  
  61. void CBoxManDlg::ReDrawMap(int x1, int y1, int x2, int y2, int x3, int y3)
  62. {
  63.     switch (m_cMap[y2][x2])
  64.     {
  65.     case MAP_BACK:           //地图有问题
  66.         MessageBox("地图有问题");
  67.         break;
  68.     case MAP_WHITEWALL:          
  69.         break;
  70.     case MAP_BLUEWALL:           
  71.         m_cMap[y2][x2] = MAP_MAN;
  72.         if (m_cMap[y1][x1] == MAP_MAN)
  73.             m_cMap[y1][x1] = MAP_BLUEWALL;
  74.         else if (m_cMap[y1][x1] == MAP_MANBALL)
  75.             m_cMap[y1][x1] = MAP_BALL;
  76.         m_ptManPosition.x = x2;
  77.         m_ptManPosition.y = y2;
  78. passtime++;
  79.         break;
  80.     case MAP_BALL:            
  81.         m_cMap[y2][x2] = MAP_MANBALL;
  82.         if (m_cMap[y1][x1] == MAP_MAN)
  83.             m_cMap[y1][x1] = MAP_BLUEWALL;
  84.         else if (m_cMap[y1][x1] == MAP_MANBALL)
  85.             m_cMap[y1][x1] = MAP_BALL;        
  86.         m_ptManPosition.x = x2;
  87.         m_ptManPosition.y = y2;
  88. passtime++;
  89.         break;
  90.     case MAP_BOX:         
  91.         if (m_cMap[y3][x3] == MAP_BALL) 
  92.         {
  93.             m_cMap[y3][x3] = MAP_REDBOX;
  94.             m_cMap[y2][x2] = MAP_MAN;
  95.             if (m_cMap[y1][x1] == MAP_MAN)
  96.                 m_cMap[y1][x1] = MAP_BLUEWALL;
  97.             else if (m_cMap[y1][x1] == MAP_MANBALL)
  98.                 m_cMap[y1][x1] = MAP_BALL;
  99.             m_ptManPosition.x = x2;
  100.             m_ptManPosition.y = y2;
  101. passtime++;
  102.         }
  103.         else if (m_cMap[y3][x3] == MAP_BLUEWALL) 
  104.         {
  105.             m_cMap[y3][x3] = MAP_BOX;
  106.             m_cMap[y2][x2] = MAP_MAN;
  107.             if (m_cMap[y1][x1] == MAP_MAN)
  108.                 m_cMap[y1][x1] = MAP_BLUEWALL;
  109.             else if (m_cMap[y1][x1] == MAP_MANBALL)
  110.                 m_cMap[y1][x1] = MAP_BALL;
  111.             m_ptManPosition.x = x2;
  112.             m_ptManPosition.y = y2;
  113. passtime++;
  114.         }
  115.         break;
  116.     case MAP_REDBOX:             
  117.         if (m_cMap[y3][x3] == MAP_BALL)
  118.         {
  119.             m_cMap[y3][x3] = MAP_REDBOX;
  120.             m_cMap[y2][x2] = MAP_MANBALL;
  121.             if (m_cMap[y1][x1] == MAP_MAN)
  122.                 m_cMap[y1][x1] = MAP_BLUEWALL;
  123.             else if (m_cMap[y1][x1] == MAP_MANBALL)
  124.                 m_cMap[y1][x1] = MAP_BALL;
  125.             m_ptManPosition.x = x2;
  126.             m_ptManPosition.y = y2;
  127. passtime++;
  128.         }
  129.         else if (m_cMap[y3][x3] == MAP_BLUEWALL)
  130.         {
  131.             m_cMap[y3][x3] = MAP_BOX;
  132.             m_cMap[y2][x2] = MAP_MANBALL;
  133.             if (m_cMap[y1][x1] == MAP_MAN)
  134.                 m_cMap[y1][x1] = MAP_BLUEWALL;
  135.             else if (m_cMap[y1][x1] == MAP_MANBALL)
  136.                 m_cMap[y1][x1] = MAP_BALL;
  137.             m_ptManPosition.x = x2;
  138.             m_ptManPosition.y = y2;
  139. passtime++;
  140.         }        
  141.         break;
  142.     case MAP_MAN:            //地图有问题
  143.         MessageBox("地图有问题");
  144.         break;
  145.     case MAP_MANBALL:            //地图有问题
  146.         MessageBox("地图有问题");
  147.         break;
  148.     }
  149. }
  150.  
  151. void CBoxManDlg::loadMap(int iMissionNum)
  152. {
  153.     CString str;
  154.     str.Format("[%d]", iMissionNum);
  156. FILE *pFile = fopen("map.txt", "rb");
  157. if (pFile == NULL)
  158.         return;
  160.     char cTmp[20];
  161.     fgets(cTmp, 20, pFile);
  162.     while (strncmp(cTmp, str, 3) != 0)
  163.     {
  164.         fgets(cTmp, 20, pFile);
  165.     }
  167.     for (int i = 0; i < 14; i++)
  168.         fgets(m_cMap[i], 20, pFile);
  170.     fclose(pFile);
  171. }

四、游戏规则模块的设计与实现

游戏规则模块，注意负责游戏规则的判断，其设计方法比较简单，需要在每次玩家移动主角后，对当前地图数组进行判断

  1. BOOL CBoxManDlg::isFinish()
  2. {
  3.     for (int i = 0; i < 14; i++)
  4.     {
  5.         for (int j = 0; j < 16; j++)
  6.         {
  7.             if (m_cMap[i][j] == MAP_BALL || m_cMap[i][j] == MAP_MANBALL)
  8. {
  9.                 return FALSE;
  10. }
  11.         }
  12.     }
  13.     return TRUE;
  14. }

五、主对话框的设计与实现

主要有如下几个部分

1：游戏初始化处理函数

2：菜单初始化处理函数

3：绘图函数处理

  1. void CBoxManDlg::OnPaint() 
  2. {
  3. if (IsIconic())
  4. {
  5. CPaintDC dc(this); // device context for painting
  6.  
  7. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  8.  
  9. // Center icon in client rectangle
  10. int cxIcon = GetSystemMetrics(SM_CXICON);
  11. int cyIcon = GetSystemMetrics(SM_CYICON);
  12. CRect rect;
  13. GetClientRect(&rect);
  14. int x = (rect.Width() - cxIcon + 1) / 2;
  15. int y = (rect.Height() - cyIcon + 1) / 2;
  16.  
  17. // Draw the icon
  18. dc.DrawIcon(x, y, m_hIcon);
  19. }
  20. else
  21. {
  22. CPaintDC dc(this);
  23. drawMap(&dc);
  24. CDialog::OnPaint();
  25. }
  26. }

 

 

 创作不易 觉得有帮助请点赞关注收藏~~~

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览44032 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪