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

　　上一篇中，我们添加了可以自动行驶的敌人坦克，今天我们给主战坦克添加最核心的功能——开炮。

　　第一次重构

　　既然要开炮，就要有炮弹。我们自然就想到要新建一个炮弹类。为了符合我们之前的设计思想，我们需要给这个新的炮弹类找一个基类。用Tank类作基类貌似不太合适，于是，我们要重构代码。

　　我们创建一个全新的Object类作为今后程序中所有类的基类。新建文件Object.h，内容如下：

C++代码
  1. #ifndef __OBJECT_H__  
  2. #define __OBJECT_H__  
  3.   
  4. #include "Graphic.h"  
  5.   
  6. enum Dir { UP, DOWN, LEFT, RIGHT };  
  7.   
  8. class Object  
  9. {  
  10. public:  
  11.     // 绘图  
  12.     virtual void Display() = 0;  
  13.   
  14.     // 移动  
  15.     virtual void Move() = 0;  
  16.   
  17.     // 判断是否消失  
  18.     virtual bool IsDisappear() = 0;  
  19.   
  20. protected:  
  21.     // 计算势力范围  
  22.     virtual void CalculateSphere() = 0;  
  23.   
  24.     // 位置  
  25.     Point m_pos;  
  26.     // 势力范围  
  27.     Rect m_rectSphere;   
  28.     // 颜色  
  29.     COLORREF m_color;  
  30.     // 方向  
  31.     Dir m_dir;  
  32.     // 存在状态  
  33.     bool m_bDisappear;  
  34.     // 单次前进步长  
  35.     int m_step;  
  36. };  
  37.   
  38. #endif  

　　在这个文件中，我们把之前Tank类中的能够被炮弹类复用的代码提取了出来，大家一定很熟悉。这里新加入了一个m_bDisappear属性和IsDisappear()方法，它们用来标明当前对象的生命周期是否结束。这个后面会细说。

　　在Java等以面向对象为基础的语言中，都有Object类作为所有类的基类，这样做的最大好处是可以利用多态的原理对系统中的所有对象进行统一管理。

　　新的Tank类

　　我们让Tank类从Object类中继承，代码如下：

　　Tank.h

C++代码
  1. #ifndef __TANK_H__  
  2. #define __TANK_H__  
  3.   
  4. #include "Object.h"  
  5.   
  6. #include <list>  
  7.   
  8. using namespace std;  
  9.   
  10. class Tank : public Object  
  11. {  
  12. public:  
  13.     Tank()  
  14.     {  
  15.         m_pos.Set(300, 300);  
  16.   
  17.         this->CalculateSphere();  
  18.   
  19.         m_color = YELLOW;  
  20.         m_dir = Dir::UP;  
  21.         m_step = 4;  
  22.   
  23.         m_bDisappear = false;  
  24.     }  
  25.   
  26.     ~Tank(){}  
  27.   
  28.     void Display()  
  29.     {  
  30.         // Display  
  31.     }  
  32.   
  33.     void Move()  
  34.     {  
  35.         // Move  
  36.     }  
  37.   
  38.     // 射击  
  39.     void Shoot(list<Object*>& lstBullets)  
  40.     {  
  41.         // Shoot  
  42.     }  
  43.   
  44.     bool IsDisappear()  
  45.     {  
  46.         return m_bDisappear;  
  47.     }  
  48.   
  49. protected:  
  50.     void CalculateSphere()  
  51.     {  
  52.         // Calculate Sphere  
  53.     }  
  54. };  
  55.   
  56. #endif  

　　Tank类中，实现了所有Object类定义的虚函数，但并没有实际代码，因为按照之前的继承关系，它依然是MainTank和EnemyTank两个类的基类。

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

　　它们之间的继承关系如上图所示。

　　这里重点看一下这个新加的函数：

C++代码
  1. // 射击  
  2. void Shoot(list<Object*>& lstBullets)  
  3. {  
  4.     // Shoot  
  5. }  

　　这个函数的参数是一个Object指针链表，我们需要实现的开炮方法其实是在传入的列表中加入新的炮弹信息即可。

　　修改了Tank类之后，MainTank和EnemyTank两个类几乎不用任何修改。

　　接下来我们开始今天的重点，实现开炮功能。

　　炮弹的实现

　　新建文件Bullet.h，里面加入炮弹类的声明：

C++代码
  1. #ifndef __BULLET_H__  
  2. #define __BULLET_H__  
  3.   
  4. #include "Object.h"  
  5.   
  6. class Bullet : public Object  
  7. {  
  8. public:  
  9.     Bullet();  
  10.     Bullet(Point pos, Dir dir, COLORREF color);  
  11.     ~Bullet();  
  12.   
  13.     void Display();  
  14.   
  15.     void Move();  
  16.   
  17.     bool IsDisappear()  
  18.     {  
  19.         return m_bDisappear;  
  20.     }  
  21.   
  22. protected:  
  23.     void CalculateSphere();  
  24. };  
  25.   
  26. #endif  

　　Bullet类继承了Object类，初始化的时候需要设置位置、方向和颜色。炮弹的位置需要参考发射炮弹的坦克的位置，而移动方向也和发射方向有关，因此这些参数都需要从外部获取。

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

　　我们看看炮弹类的具体实现，新建Bullet.cpp，加入下面代码：

C++代码
  1. #include "Bullet.h"  
  2.   
  3. Bullet::Bullet()  
  4. {  
  5. }  
  6.   
  7. Bullet::Bullet(Point pos, Dir dir, COLORREF color)  
  8. {  
  9.     m_pos = pos;  
  10.     m_dir = dir;  
  11.     m_color = color;  
  12.   
  13.     m_step = 20;  
  14.   
  15.     m_bDisappear = false;  
  16.   
  17.     CalculateSphere();  
  18. }  
  19.   
  20. Bullet::~Bullet()  
  21. {  
  22.   
  23. }  
  24.   
  25. // 绘图  
  26. void Bullet::Display()  
  27. {  
  28.     COLORREF fill_color_save = getfillcolor();  
  29.     COLORREF color_save = getcolor();  
  30.   
  31.     setfillcolor(m_color);  
  32.     setcolor(m_color);  
  33.   
  34.     fillcircle(m_pos.GetX() - 1, m_pos.GetY() - 1, 4);  
  35.   
  36.     setcolor(color_save);  
  37.     setfillcolor(fill_color_save);  
  38. }  
  39.   
  40. // 移动  
  41. void Bullet::Move()  
  42. {  
  43.     switch (m_dir)  
  44.     {  
  45.     case UP:  
  46.         m_pos.SetY(m_pos.GetY() - m_step);  
  47.         CalculateSphere();  
  48.         if (m_rectSphere.GetStartPoint().GetY() < Graphic::GetBattleGround().GetStartPoint().GetY())  
  49.         {  
  50.             m_bDisappear = true;  
  51.         }  
  52.         break;  
  53.     case DOWN:  
  54.         m_pos.SetY(m_pos.GetY() + m_step);  
  55.         CalculateSphere();  
  56.         if (m_rectSphere.GetEndPoint().GetY() > Graphic::GetBattleGround().GetEndPoint().GetY())  
  57.         {  
  58.             m_bDisappear = true;  
  59.         }  
  60.         break;  
  61.     case LEFT:  
  62.         m_pos.SetX(m_pos.GetX() - m_step);  
  63.         CalculateSphere();  
  64.         if (m_rectSphere.GetStartPoint().GetX() < Graphic::GetBattleGround().GetStartPoint().GetX())  
  65.         {  
  66.             m_bDisappear = true;  
  67.         }  
  68.         break;  
  69.     case RIGHT:  
  70.         m_pos.SetX(m_pos.GetX() + m_step);  
  71.         CalculateSphere();  
  72.         if (m_rectSphere.GetEndPoint().GetX() > Graphic::GetBattleGround().GetEndPoint().GetX())  
  73.         {  
  74.             m_bDisappear = true;  
  75.         }  
  76.         break;  
  77.     default:  
  78.         break;  
  79.     }      
  80. }  
  81.   
  82. void Bullet::CalculateSphere()  
  83. {  
  84.     m_rectSphere.Set(m_pos.GetX() - 2, m_pos.GetY() - 2, m_pos.GetX() + 2, m_pos.GetY() + 2);  
  85. }  

　　这里的代码是不是很熟悉呢？

　　构造函数中，m_step设为20，因为炮弹的速度必须远远大于坦克行驶的速度才有意义。

　　Display()中，我们用炮弹的位置和颜色填充一个圆形的炮弹。

　　Move()方法和坦克几乎没有区别，只是在炮弹飞出战场区域时会将m_bDisappear属性置为true表示它应该消失了。

　　这样炮弹的功能就全部实现完了。

　　发射炮弹功能

　　由于继承了修改过得Tank类，MainTank的代码略有改动：

C++代码
  1. class MainTank : public Tank  
  2. {  
  3. public:  
  4.     MainTank() : Tank()  
  5.     {  
  6.         m_pos.Set(300, 300);  
  7.   
  8.         this->CalculateSphere();  
  9.   
  10.         m_color = YELLOW;  
  11.         m_dir = Dir::UP;  
  12.         m_step = 4;  
  13.     }  
  14.   
  15.     ~MainTank(){}  
  16.   
  17.     void SetDir(Dir dir);  
  18.     void Display();  
  19.     void Move();  
  20.     void Shoot(list<Object*>& lstBullets);  
  21.   
  22. protected:  
  23.     void CalculateSphere();  
  24.   
  25.     // 绘制坦克主体  
  26.     void DrawTankBody();  
  27. };  

　　我们重点看看Shoot函数的实现：

C++代码
  1. void MainTank::Shoot(list<Object*>& lstBullets)  
  2. {  
  3.     Bullet* pBullet = new Bullet(m_pos, m_dir, m_color);  
  4.   
  5.     lstBullets.push_back(pBullet);  
  6. }  

　　是不是简单的难以置信呢，每次调用这个方法时，创建一个新的炮弹添加到传入的list中即可。创建炮弹时，我们将坦克自身的属性传给炮弹对象。

　　main.cpp修改

　　这里修改的代码较多，先贴出来：

C++代码
  1. #pragma warning(disable:4996)  
  2.   
  3. #include <iostream>  
  4. #include <conio.h>  
  5. #include <time.h>  
  6.   
  7. #include <list>  
  8.   
  9. #include "Graphic.h"  
  10. #include "MainTank.h"  
  11. #include "EnemyTank.h"  
  12.   
  13. using namespace std;  
  14.   
  15. #define MAX_TANKS 10  
  16.   
  17. void main()  
  18. {  
  19.     srand((unsigned)time(NULL));  
  20.   
  21.     Graphic::Create();  
  22.   
  23.     MainTank mainTank;  
  24.   
  25.     list<Tank*> lstTanks;  
  26.     lstTanks.clear();  
  27.   
  28.     for (int i = 0; i < MAX_TANKS; i++)  
  29.     {  
  30.         lstTanks.push_back(new EnemyTank());  
  31.     }  
  32.   
  33.     list<Object*> lstBullets;  
  34.     lstBullets.clear();  
  35.   
  36.     bool loop = true;  
  37.     bool skip = false;  
  38.     while (loop)  
  39.     {  
  40.         if (kbhit())  
  41.         {  
  42.             int key = getch();  
  43.   
  44.             switch (key)  
  45.             {  
  46.             // Up  
  47.             case 72:  
  48.                 mainTank.SetDir(Dir::UP);  
  49.                 break;  
  50.             // Down  
  51.             case 80:   
  52.                 mainTank.SetDir(Dir::DOWN);  
  53.                 break;  
  54.             // Left  
  55.             case 75:   
  56.                 mainTank.SetDir(Dir::LEFT);  
  57.                 break;  
  58.             // Right  
  59.             case 77:   
  60.                 mainTank.SetDir(Dir::RIGHT);  
  61.                 break;  
  62.             case 224: // 方向键高8位  
  63.                 break;  
  64.             // Esc  
  65.             case 27:  
  66.                 loop = false;  
  67.                 break;  
  68.             // Space  
  69.             case 32:  
  70.                   mainTank.Shoot(lstBullets);  
  71.                 break;  
  72.             // Enter  
  73.             case 13:  
  74.                 if (skip)  
  75.                     skip = false;  
  76.                 else  
  77.                     skip = true;  
  78.                 break;  
  79.             default:   
  80.                 break;  
  81.             }  
  82.         }  
  83.   
  84.         if (!skip)  
  85.         {  
  86.             cleardevice();  
  87.   
  88.             Graphic::DrawBattleGround();  
  89.   
  90.             mainTank.Move();  
  91.             mainTank.Display();  
  92.   
  93.             for (list<Tank*>::iterator it = lstTanks.begin(); it != lstTanks.end(); it++)  
  94.             {  
  95.                 (*it)->Move();  
  96.                 (*it)->Display();  
  97.             }  
  98.   
  99.             for (list<Object*>::iterator it = lstBullets.begin(); it != lstBullets.end();)  
  100.             {  
  101.                 (*it)->Move();  
  102.   
  103.                 if ((*it)->IsDisappear())  
  104.                 {  
  105.   
  106.                     delete *it;  
  107.                     it = lstBullets.erase(it);  
  108.                     continue;  
  109.                 }  
  110.   
  111.                 (*it)->Display();  
  112.                 it++;  
  113.             }  
  114.         }  
  115.   
  116.         Sleep(200);  
  117.     }  
  118.   
  119.   
  120.     // Destroy  
  121.     for (list<Tank*>::iterator it = lstTanks.begin(); it != lstTanks.end(); it++)  
  122.     {  
  123.         delete *it;  
  124.     }  
  125.     lstTanks.clear();  
  126.   
  127.     for (list<Object*>::iterator it = lstBullets.begin(); it != lstBullets.end(); it++)  
  128.     {  
  129.         delete *it;  
  130.     }  
  131.     lstBullets.clear();  
  132.   
  133.     Graphic::Destroy();  
  134. }  

　　这里主要有下面几处修改。

　　1. 坦克集合修改

　　之前的坦克用数组实现，由于数组大小是固定的，而且不容易随意增加和删除，因此我们用了方便删除的list来实现。这样最大的好处是后面如果敌人坦克被击毁之后能够方便地随时删除掉。

C++代码
  1. for (int i = 0; i < MAX_TANKS; i++)  
  2. {  
  3.     lstTanks.push_back(new EnemyTank());  
  4. }  

　　坦克的创建也非常简单，new出来一个丢进list中即可。

　　注意，在程序退出前一定要把每个活着的坦克都释放掉：

C++代码
  1. for (list<Tank*>::iterator it = lstTanks.begin(); it != lstTanks.end(); it++)  
  2. {  
  3.     delete *it;  
  4. }  
  5. lstTanks.clear();  

　　2. 炮弹集合

　　和坦克集合一样，炮弹集合也用了list来实现，方便增加和删除。

　　3. 开炮功能

　　在按空格键之后，调用MainTank的Shoot方法将新炮弹添加到炮弹集合中。

C++代码
  1. mainTank.Shoot(lstBullets);  

　　4. 绘制炮弹

　　在程序的每个循环中，需要绘制炮弹的新位置。当炮弹消失时，释放掉相应的对象。

C++代码
  1. for (list<Object*>::iterator it = lstBullets.begin(); it != lstBullets.end();)  
  2. {  
  3.     (*it)->Move();  
  4.   
  5.     if ((*it)->IsDisappear())  
  6.     {  
  7.   
  8.         delete *it;  
  9.         it = lstBullets.erase(it);  
  10.         continue;  
  11.     }  
  12.   
  13.     (*it)->Display();  
  14.     it++;  
  15. }  

　　今天先不添加敌人坦克的开炮功能，让我们的主战坦克自由地开炮吧，现在运行一下程序看看效果是不是很炫，哈哈。

　　今天的全部代码已经上传到了GitHub上，欢迎下载。

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