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.cpbsu.com/software/676.html
2016年12月30日
作者:雞啄米 分類:軟件開發 瀏覽: 評論:1