C++实战项目：坦克大战（一）

　　对坦克大战情有独钟是因为大学时候第一次参加程序设计比赛就做的这个游戏。当时用的语言是Java，那个比赛让我悟出了面向对象的强大之处，我也是从那时开始接触设计模式的。对我而言，坦克大战有着非同寻常的意义，所以一定要带大家用C++实现一下。

　　知识准备

　　建议大家先看看面向对象编程的三个重要特性，之后再来学习后面的内容。

C++实战项目：坦克大战（一）

　　代码分享

　　这个项目中的代码会在GitHub上发布，里面的每一个分支对应着简书中的每一篇文章。

　　比如，今天是第一篇文章，这一篇里完成的代码会上传在day1这个分支中，以此类推。

　　坦克大战

　　我们依然使用EasyX在控制台程序中制作这个游戏程序。这一篇的主要任务是在屏幕上画出一个白色的主战坦克，可以通过方向键控制它的前进方向。效果如下：

C++实战项目：坦克大战（一）

　　下面我们正式开始。

　　画布类

　　在这个工程中，我们将EasyX画布相关的功能封装在一个Graphic类中，创建两个文件：Graphic.h和Graphic.cpp。

　　Graphic.h

C++代码
  1. #ifndef __GRAPHIC_H__  
  2. #define __GRAPHIC_H__  
  3.   
  4. #include <graphics.h>  
  5.   
  6. #define SCREEN_WIDTH    1024  
  7. #define SCREEN_HEIGHT    768  
  8.   
  9. class Graphic  
  10. {  
  11. public:  
  12.     static void Create();  
  13.     static void Destroy();  
  14.   
  15.     static int GetScreenWidth();  
  16.     static int GetScreenHeight();  
  17.   
  18. private:  
  19.     static int m_screen_width;  
  20.     static int m_screen_height;  
  21. };  
  22.   
  23. #endif  

　　Graphic.cpp

C++代码
  1. #include "Graphic.h"  
  2.   
  3. int Graphic::m_screen_width = SCREEN_WIDTH;  
  4. int Graphic::m_screen_height = SCREEN_HEIGHT;  
  5.   
  6. void Graphic::Create()  
  7. {  
  8.     initgraph(m_screen_width, m_screen_height);  
  9. }  
  10.   
  11. void Graphic::Destroy()  
  12. {  
  13.     closegraph();  
  14. }  
  15.   
  16. int Graphic::GetScreenWidth()  
  17. {  
  18.     return m_screen_width;  
  19. }  
  20.   
  21. int Graphic::GetScreenHeight()  
  22. {  
  23.     return m_screen_height;  
  24. }  

　　这个类使用的是静态成员变量和静态成员函数，要注意静态成员变量的初始化时在类外进行的。通过这个类可以实现创建和销毁画布的功能，还能够让其他代码随时通过这个类拿到画布的尺寸。

　　坦克抽象类

　　由于我们的程序是要通过EasyX画在屏幕上，各种元素都需要统一放在可以遍历的数据结构中方便操作，所以我们在实现坦克代码时会用到多态。这里先创建一个坦克的抽象类。新建文件Tank.h，加入下面代码：

C++代码
  1. #ifndef __TANK_H__  
  2. #define __TANK_H__  
  3.   
  4. #include "Graphic.h"  
  5.   
  6. enum Dir { UP, DOWN, LEFT, RIGHT };  
  7.   
  8. class Tank  
  9. {  
  10. public:  
  11.     virtual void Display() = 0;  
  12.     virtual void Move() = 0;  
  13.   
  14. protected:  
  15.     int m_x;  
  16.     int m_y;  
  17.     COLORREF m_color;  
  18.   
  19.     Dir m_dir;  
  20.     int m_step;  
  21. };  
  22.   
  23. #endif  

　　所有坦克都需要引用的东西会定义在这个文件中。这里定义了一个枚举类型，表示方向用的。我们的程序只考虑四个方向，如果需要让坦克可以有八个前进方向后面可以在这里扩充其他方向。

　　坦克抽象类中，我们定义了两个函数，Display()和Move()大家很熟悉了，在星空项目里用的很多，主要是负责将自己画在屏幕上和移动自己。

　　属性中m_dir保存坦克的行驶方向，Display和Move都需要使用它。

　　主战坦克

　　所谓主战坦克就是玩家控制的坦克，所有的坦克中，只有这个一个是可以控制的。这一点它比较特殊。

　　创建文件MainTank.h，写入下面代码：

C++代码
  1. #ifndef __MAIN_TANK__  
  2. #define __MAIN_TANK__  
  3.   
  4. #include "Tank.h"  
  5.   
  6. class MainTank : public Tank  
  7. {  
  8. public:  
  9.     MainTank()  
  10.     {  
  11.         m_x = 400;  
  12.         m_y = 300;  
  13.         m_color = WHITE;  
  14.         m_dir = Dir::UP;  
  15.         m_step = 2;  
  16.     }  
  17.   
  18.     ~MainTank(){}  
  19.   
  20.     // 设置行驶方向  
  21.     void SetDir(Dir dir);  
  22.   
  23.     void Display();  
  24.     void Move();  
  25.   
  26. protected:  
  27.     // 绘制坦克主体  
  28.     void DrawTankBody(int style);  
  29. };  
  30.   
  31. #endif  

　　这个类继承了Tank类，在初始化时给各个属性赋初值。我们默认主战坦克一开始在屏幕中间，行驶方向向上，颜色为白色。

　　我们主战坦克的形状如下：

C++实战项目：坦克大战（一）

　　我们来看看怎么实现它。创建文件MainTank.cpp代码如下：

C++代码
  1. #include "MainTank.h"  
  2.   
  3. void MainTank::SetDir(Dir dir)  
  4. {  
  5.     m_dir = dir;  
  6. }  
  7.   
  8. void MainTank::DrawTankBody(int style)  
  9. {  
  10.     fillrectangle(m_x - 4, m_y - 4, m_x + 4, m_y + 4);  
  11.   
  12.     if (style == 1)  
  13.     {  
  14.         fillrectangle(m_x - 8, m_y - 6, m_x - 6, m_y + 6);  
  15.         fillrectangle(m_x + 6, m_y - 6, m_x + 8, m_y + 6);  
  16.     }  
  17.     else  
  18.     {  
  19.         fillrectangle(m_x - 6, m_y - 8, m_x + 6, m_y - 6);  
  20.         fillrectangle(m_x - 6, m_y + 6, m_x + 6, m_y + 8);  
  21.     }  
  22. }  
  23.   
  24. void MainTank::Display()  
  25. {  
  26.     COLORREF color_save = getfillcolor();  
  27.   
  28.     setfillcolor(m_color);  
  29.   
  30.     switch (m_dir)  
  31.     {  
  32.     case UP:  
  33.         DrawTankBody(1);  
  34.         line(m_x, m_y, m_x, m_y - 10);  
  35.         break;  
  36.     case DOWN:  
  37.         DrawTankBody(1);  
  38.         line(m_x, m_y, m_x, m_y + 10);  
  39.         break;  
  40.     case LEFT:  
  41.         DrawTankBody(0);  
  42.         line(m_x, m_y, m_x - 10, m_y);  
  43.         break;  
  44.     case RIGHT:  
  45.         DrawTankBody(0);  
  46.         line(m_x, m_y, m_x + 10, m_y);  
  47.         break;  
  48.     default:  
  49.         break;  
  50.     }  
  51.   
  52.     setfillcolor(color_save);  
  53. }  
  54.   
  55. void MainTank::Move()  
  56. {  
  57.     switch (m_dir)  
  58.     {  
  59.     case UP:  
  60.         m_y -= m_step;  
  61.         if (m_y < 0)  
  62.             m_y = Graphic::GetScreenHeight() - 1;  
  63.         break;  
  64.     case DOWN:  
  65.         m_y += m_step;  
  66.         if (m_y > Graphic::GetScreenHeight())  
  67.             m_y = 1;  
  68.         break;  
  69.     case LEFT:  
  70.         m_x -= m_step;  
  71.         if (m_x < 0)  
  72.             m_x = Graphic::GetScreenWidth() - 1;  
  73.         break;  
  74.     case RIGHT:  
  75.         m_x += m_step;  
  76.         if (m_x > Graphic::GetScreenWidth())  
  77.             m_x = 1;  
  78.         break;  
  79.     default:  
  80.         break;  
  81.     }  
  82. }  

　　SetDir()

　　这个很简单，就是修改成员变量的值。通过这个函数能够改变坦克的行驶方向。

　　DrawTankBody()

　　这个函数负责画坦克的主题部分，一个正方形的坦克身和两个矩形的履带。由于坦克上下行驶和左右行驶形状不同，因此通过一个参数负责绘制不同的形状。

　　Display()

　　这个是核心的绘制方法，提供给外部调用的。这里主要是两部分工作：

　　• 判断坦克的行驶方向，之后调用DrawTankBody绘制出坦克身

　　• 根据行驶方向画上炮管

　　Move()

　　这个函数每执行一次，坦克向前移动m_step长度。当超出屏幕边沿时，从另一侧重新出现，行驶方向不变。是不是很简单。

　　键盘事件监听

　　最后到了我们的主程序了，新建文件main.cpp，加入下面代码：

C++代码
  1. #pragma warning(disable:4996)  
  2.   
  3. #include <iostream>  
  4. #include <conio.h>  
  5. #include <time.h>  
  6.   
  7. #include "Graphic.h"  
  8. #include "MainTank.h"  
  9.   
  10. using namespace std;  
  11.   
  12. void main()  
  13. {  
  14.     Graphic::Create();  
  15.   
  16.     MainTank mainTank;  
  17.   
  18.     bool loop = true;  
  19.     bool skip = false;  
  20.     while (loop)  
  21.     {  
  22.         if (kbhit())  
  23.         {  
  24.             int key = getch();  
  25.   
  26.             switch (key)  
  27.             {  
  28.             // Up  
  29.             case 72:  
  30.                 mainTank.SetDir(Dir::UP);  
  31.                 break;  
  32.             // Down  
  33.             case 80:   
  34.                 mainTank.SetDir(Dir::DOWN);  
  35.                 break;  
  36.             // Left  
  37.             case 75:   
  38.                 mainTank.SetDir(Dir::LEFT);  
  39.                 break;  
  40.             // Right  
  41.             case 77:   
  42.                 mainTank.SetDir(Dir::RIGHT);  
  43.                 break;  
  44.             case 224: // 方向键高8位  
  45.                 break;  
  46.             // Esc  
  47.             case 27:  
  48.                 loop = false;  
  49.                 break;  
  50.             // Space  
  51.             case 32:  
  52.                 break;  
  53.             // Enter  
  54.             case 13:  
  55.                 if (skip)  
  56.                     skip = false;  
  57.                 else  
  58.                     skip = true;  
  59.                 break;  
  60.             default:   
  61.                 break;  
  62.             }  
  63.         }  
  64.   
  65.         if (!skip)  
  66.         {  
  67.             cleardevice();  
  68.   
  69.             mainTank.Move();  
  70.             mainTank.Display();  
  71.         }  
  72.   
  73.         Sleep(200);  
  74.     }  
  75.   
  76.     Graphic::Destroy();  
  77. }  

　　这里需要说明的是，我们通过kbhit()捕捉键盘动作，之后再通过getch()得到按下键的码值。有了码值，我们就可以做相应的操作了。这里主要实现了下面几个功能：

　　• 方向键

　　按了上下左右方向键之后，坦克相应地进行转向。

　　• Esc键

　　按了Esc键之后，程序退出。

　　• Enter键

　　按了Enter键之后，程序暂停，再按一下程序继续。

　　好了，我们现在来运行一下程序。是不是看到了一辆神奇的白色坦克呢？

除非特别注明，鸡啄米文章均为原创
转载请标明本文地址：http://www.jizhuomi.com/software/669.html
2016年12月7日
作者:鸡啄米 分类:软件开发 浏览: 评论:11