找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 8686|回復: 10
打印 上一主題 下一主題
收起左側(cè)

坦克大戰(zhàn)游戲的C++語言程序?qū)崿F(xiàn)

  [復制鏈接]
跳轉(zhuǎn)到指定樓層
樓主
ID:367557 發(fā)表于 2018-7-8 22:40 | 只看該作者 回帖獎勵 |倒序瀏覽 |閱讀模式
一、游戲內(nèi)容及特點描述
游戲內(nèi)容:玩家自己控制一輛黃色的坦克，而敵方坦克為白色，一秒發(fā)射一顆炮彈，玩家通過鍵盤的方向鍵來控制黃色坦克的前進方向，空格鍵來控制發(fā)射炮彈，當炮彈與白色的敵方坦克相撞時，白色坦克與炮彈一起消失，玩家積十分，當所有白色坦克被消滅時，玩家進入下一關(guān)，當白色坦克發(fā)射的炮彈與玩家控制的黃色坦克累積相撞三次時，黃色坦克與炮彈一起消失，游戲結(jié)束，玩家獲得最終分數(shù)。
特點描述:1*玩家可自主控制坦克進行游戲，規(guī)避敵人子彈。
         2*白色的敵方坦克方向隨機變動。
         3*玩家壓Q鍵時可以向四面發(fā)射密集的炮彈。
         4*游戲?qū)嵭嘘P(guān)卡制，當所有白色坦克都被消滅時，游戲進入下一關(guān)。
         5*玩家有三次被地方坦克擊中而不結(jié)束游戲的機會。
         6*游戲采用分數(shù)積分制，使游戲更富有挑戰(zhàn)性。

C++語言源程序如下:
  1. Bomb.cpp
  2. #include "Bomb.h"

  4. Bomb::Bomb()
  5. {
  6.         this->m_bDisappear = false;
  7.         this->m_color = YELLOW;
  8.         this->m_dir = UP;
  9. }

  11. Bomb::Bomb(Point pos, BombType type) : Bomb()
  12. {
  13.         this->m_pos = pos;
  14.         this->m_type = type;

  16.         switch (m_type)
  17.         {
  18.         case LARGE:
  19.                 m_timer = 8;
  20.                 break;
  21.         case SMALL:
  22.                 m_timer = 4;
  23.                 break;
  24.         default:
  25.                 break;
  26.         }
  27. }
  28. Bomb.h
  29. void Bomb::Display()
  30. {
  31.         COLORREF fill_color_save = getfillcolor();
  32.         COLORREF color_save = getcolor();

  34.         setfillcolor(m_color);
  35.         setcolor(RED);

  37.         fillcircle(m_pos.GetX(), m_pos.GetY(), 8 - m_timer);

  39.         setcolor(color_save);
  40.         setfillcolor(fill_color_save);
  41. }

  43. void Bomb::Move()
  44. {
  45.         m_timer -= 2;

  47.         if (m_timer < 0)
  48.         {
  49.                 m_bDisappear = true;
  50.         }

  52. }

  54. bool Bomb::IsDisappear()
  55. {
  56.         return m_bDisappear;
  57. }

  59. void Bomb::Boom(list<Object*>& lstBombs)
  60. {
  61.         // Do nothing
  62. }

  64. void Bomb::CalculateSphere()
  65. {
  66.         // Do nothing
  67. }

  69. #ifndef __BOMB_H__
  70. #define __BOMB_H__

  72. #include "Object.h"

  74. enum BombType
  75. {
  76.         LARGE,
  77.         SMALL
  78. };

  80. class Bomb : public Object
  81. {
  82. public:
  83.         Bomb();
  84.         Bomb(Point pos, BombType type);
  85.         ~Bomb(){}

  87.         void Display();

  89.         void Move();

  91.         void Boom(list<Object*>& lstBombs);
  92.         
  93.         bool IsDisappear();
  94.         void SetDisappear(){}

  96.         Rect GetSphere()
  97.         {
  98.                 return m_rectSphere;
  99.         }

  101. protected:
  102.         void CalculateSphere();
  103.         
  104.         BombType m_type;
  105.         int m_timer;
  106. };

  108. #endif
  109. Bullet.cpp
  110. #include "Bullet.h"

  112. #include "Bomb.h"

  114. Bullet::Bullet()
  115. {
  116. }

  118. Bullet::Bullet(Point pos, Dir dir, COLORREF color)
  119. {
  120.         m_pos = pos;
  121.         m_dir = dir;
  122.         m_color = color;

  124.         m_step = 6;

  126.         m_bDisappear = false;

  128.         CalculateSphere();
  129. }

  131. Bullet::~Bullet()
  132. {

  134. }


  137. // 繪圖
  138. void Bullet::Display()
  139. {
  140.         COLORREF fill_color_save = getfillcolor();
  141.         COLORREF color_save = getcolor();

  143.         setfillcolor(m_color);
  144.         setcolor(m_color);

  146.         fillcircle(m_pos.GetX(), m_pos.GetY(), 4);
  147.                
  148.         setcolor(color_save);
  149.         setfillcolor(fill_color_save);
  150. }

  152. // 移動
  153. void Bullet::Move()
  154. {
  155.         switch (m_dir)
  156.         {
  157.         case UP:
  158.                 m_pos.SetY(m_pos.GetY() - m_step);
  159.                 CalculateSphere();
  160.                 if (m_rectSphere.GetStartPoint().GetY() < Graphic::GetBattleGround().GetStartPoint().GetY())
  161.                 {
  162.                         m_pos.SetY(Graphic::GetBattleGround().GetStartPoint().GetY());
  163.                         m_bDisappear = true;
  164.                 }
  165.                 break;
  166.         case DOWN:
  167.                 m_pos.SetY(m_pos.GetY() + m_step);
  168.                 CalculateSphere();
  169.                 if (m_rectSphere.GetEndPoint().GetY() > Graphic::GetBattleGround().GetEndPoint().GetY())
  170.                 {
  171.                         m_pos.SetY(Graphic::GetBattleGround().GetEndPoint().GetY());
  172.                         m_bDisappear = true;
  173.                 }
  174.                 break;
  175.         case LEFT:
  176.                 m_pos.SetX(m_pos.GetX() - m_step);
  177.                 CalculateSphere();
  178.                 if (m_rectSphere.GetStartPoint().GetX() < Graphic::GetBattleGround().GetStartPoint().GetX())
  179.                 {
  180.                         m_pos.SetX(Graphic::GetBattleGround().GetStartPoint().GetX());
  181.                         m_bDisappear = true;
  182.                 }
  183.                 break;
  184.         case RIGHT:
  185.                 m_pos.SetX(m_pos.GetX() + m_step);
  186.                 CalculateSphere();
  187.                 if (m_rectSphere.GetEndPoint().GetX() > Graphic::GetBattleGround().GetEndPoint().GetX())
  188.                 {
  189.                         m_pos.SetX(Graphic::GetBattleGround().GetEndPoint().GetX());
  190.                         m_bDisappear = true;
  191.                 }
  192.                 break;
  193.         default:
  194.                 break;
  195.         }        
  196. }

  198. void Bullet::Boom(list<Object*>& lstBombs)
  199. {
  200.         lstBombs.push_back(new Bomb(m_pos, SMALL));
  201. }

  203. void Bullet::CalculateSphere()
  204. {
  205.         m_rectSphere.Set(m_pos.GetX() - 2, m_pos.GetY() - 2, m_pos.GetX() + 2, m_pos.GetY() + 2);
  206. }
  207. Bullet.h
  208. #ifndef __BULLET_H__
  209. #define __BULLET_H__

  211. #include "Object.h"

  213. class Bullet : public Object
  214. {
  215. public:
  216.         Bullet();
  217.         Bullet(Point pos, Dir dir, COLORREF color);
  218.         ~Bullet();

  220.         void Display();

  222.         void Move();

  224.         void Boom(list<Object*>& lstBombs);

  226.         bool IsDisappear()
  227.         {
  228.                 return m_bDisappear;
  229.         }

  231.         Rect GetSphere()
  232.         {
  233.                 return m_rectSphere;
  234.         }

  236.         void SetStep(int nStep)
  237.         {
  238.                 m_step = nStep;
  239.         }

  241.         void SetDisappear()
  242.         {
  243.                 m_bDisappear = true;
  244.         }

  246. protected:
  247.         void CalculateSphere();
  248. };

  250. #endif
  251. EnemyTank.cpp
  252. #include "EnemyTank.h"

  254. #include "Bullet.h"

  256. void EnemyTank::RandomTank()
  257. {
  258.         m_pos.SetX(rand() % (Graphic::GetBattleGround().GetWidth() - 30) + 15);
  259.         m_pos.SetY(rand() % (Graphic::GetBattleGround().GetHeight() - 30) + 15);
  260.         m_color = WHITE;
  261.         m_dir = (Dir)(Dir::UP + (rand() % 4));
  262.         m_step = 1;
  263.         m_stepCnt = rand();
  264. }

  266. void EnemyTank::RandomDir(int type)
  267. {
  268.         if (type == 1)
  269.         {
  270.                 Dir dir;
  271.                 while ((dir = (Dir)(Dir::UP + (rand() % 4))) == m_dir)
  272.                 {
  273.                         // Do nothing
  274.                 }

  276.                 m_dir = dir;
  277.         }
  278.         else
  279.         {
  280.                 m_dir = (Dir)(Dir::UP + (rand() % 4));
  281.         }
  282. }

  284. void EnemyTank::Display()
  285. {
  286.         COLORREF fill_color_save = getfillcolor();
  287.         COLORREF color_save = getcolor();

  289.         setfillcolor(m_color);
  290.         setcolor(m_color);
  291.         
  292.         fillrectangle(m_pos.GetX() - 6, m_pos.GetY() - 6, m_pos.GetX() + 6, m_pos.GetY() + 6);

  294.         fillrectangle(m_rectSphere.GetStartPoint().GetX(), m_rectSphere.GetStartPoint().GetY(),
  295.                 m_rectSphere.GetStartPoint().GetX() + 4, m_rectSphere.GetStartPoint().GetY() + 4);
  296.         fillrectangle(m_rectSphere.GetEndPoint().GetX() - 4, m_rectSphere.GetStartPoint().GetY(),
  297.                 m_rectSphere.GetEndPoint().GetX(), m_rectSphere.GetStartPoint().GetY() + 4);

  299.         fillrectangle(m_rectSphere.GetStartPoint().GetX(), m_rectSphere.GetEndPoint().GetY() - 4,
  300.                 m_rectSphere.GetStartPoint().GetX() + 4, m_rectSphere.GetEndPoint().GetY());
  301.         fillrectangle(m_rectSphere.GetEndPoint().GetX() - 4, m_rectSphere.GetEndPoint().GetY() - 4,
  302.                 m_rectSphere.GetEndPoint().GetX(), m_rectSphere.GetEndPoint().GetY());
  303.         
  304.         switch (m_dir)
  305.         {
  306.         case UP:
  307.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX(), m_pos.GetY() - 15);
  308.                 break;
  309.         case DOWN:
  310.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX(), m_pos.GetY() + 15);
  311.                 break;
  312.         case LEFT:
  313.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX() - 15, m_pos.GetY());
  314.                 break;
  315.         case RIGHT:
  316.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX() + 15, m_pos.GetY());
  317.                 break;
  318.         default:
  319.                 break;
  320.         }

  322.         setcolor(color_save);
  323.         setfillcolor(fill_color_save);
  324. }

  326. void EnemyTank::Move()
  327. {
  328.         switch (m_dir)
  329.         {
  330.         case UP:
  331.                 m_pos.SetY(m_pos.GetY() - m_step);
  332.                 if (m_rectSphere.GetStartPoint().GetY() < Graphic::GetBattleGround().GetStartPoint().GetY())
  333.                 {
  334.                         m_pos.SetY(m_pos.GetY() + m_step);
  335.                         this->RandomDir(1);
  336.                 }
  337.                 break;
  338.         case DOWN:
  339.                 m_pos.SetY(m_pos.GetY() + m_step);
  340.                 if (m_rectSphere.GetEndPoint().GetY() > Graphic::GetBattleGround().GetEndPoint().GetY())
  341.                 {
  342.                         m_pos.SetY(m_pos.GetY() - m_step);
  343.                         this->RandomDir(1);
  344.                 }
  345.                 break;
  346.         case LEFT:
  347.                 m_pos.SetX(m_pos.GetX() - m_step);
  348.                 if (m_rectSphere.GetStartPoint().GetX() < Graphic::GetBattleGround().GetStartPoint().GetX())
  349.                 {
  350.                         m_pos.SetX(m_pos.GetX() + m_step);
  351.                         this->RandomDir(1);
  352.                 }
  353.                 break;
  354.         case RIGHT:
  355.                 m_pos.SetX(m_pos.GetX() + m_step);
  356.                 if (m_rectSphere.GetEndPoint().GetX() > Graphic::GetBattleGround().GetEndPoint().GetX())
  357.                 {
  358.                         m_pos.SetX(m_pos.GetX() - m_step);
  359.                         this->RandomDir(1);
  360.                 }
  361.                 break;
  362.         default:
  363.                 break;
  364.         }

  366.         CalculateSphere();

  368.         m_stepCnt++;
  369.         if (m_stepCnt % MAX_STEP_TURN == 0)
  370.         {
  371.                 //m_stepCnt = 0;
  372.                 this->RandomDir(0);
  373.         }

  375.         if (m_stepCnt % MAX_STEP_SHOOT == 0)
  376.         {
  377.                 m_bNeedShoot = true;
  378.         }
  379. }

  381. void EnemyTank::CalculateSphere()
  382. {
  383.         switch (m_dir)
  384.         {
  385.         case UP:
  386.         case DOWN:
  387.                 m_rectSphere.Set(m_pos.GetX() - 13, m_pos.GetY() - 10, m_pos.GetX() + 13, m_pos.GetY() + 10);
  388.                 break;
  389.         case LEFT:
  390.         case RIGHT:
  391.                 m_rectSphere.Set(m_pos.GetX() - 10, m_pos.GetY() - 13, m_pos.GetX() + 10, m_pos.GetY() + 13);
  392.                 break;
  393.         default:
  394.                 break;
  395.         }
  396. }

  398. void EnemyTank::Shoot(list<Object*>& lstBullets)
  399. {
  400.         Bullet* pBullet = new Bullet(m_pos, m_dir, m_color);

  402.         lstBullets.push_back(pBullet);

  404.         m_bNeedShoot = false;
  405. }
  406. EnemyTank.h
  407. #ifndef __ENEMY_TANK__
  408. #define __ENEMY_TANK__

  410. #include "Tank.h"

  412. #define MAX_STEP_TURN        20
  413. #define MAX_STEP_SHOOT        15

  415. class EnemyTank : public Tank
  416. {
  417. public:
  418.         EnemyTank()
  419.         {
  420.                 RandomTank();
  421.         }

  423.         ~EnemyTank(){}

  425.         void Display();
  426.         void Move();
  427.         void Shoot(list<Object*>& lstBullets);

  429. protected:
  430.         void CalculateSphere();
  431.         void RandomTank();
  432.         // 隨機產(chǎn)生坦克方向 type： 1, 新方向必須與之前方向不同 2, 任意一個新方向
  433.         void RandomDir(int type);

  435.         int m_stepCnt;
  436. };

  438. #endif
  439. Graphic.h
  440. #ifndef __GRAPHIC_H__
  441. #define __GRAPHIC_H__

  443. #include <graphics.h>

  445. #include "model/Rect.h"

  447. #define SCREEN_WIDTH        1024
  448. #define SCREEN_HEIGHT        768

  450. #define BATTLE_GROUND_X1 5
  451. #define BATTLE_GROUND_Y1 5
  452. #define BATTLE_GROUND_X2 800
  453. #define BATTLE_GROUND_Y2 (SCREEN_HEIGHT - BATTLE_GROUND_Y1)

  455. class Graphic
  456. {
  457. public:
  458.         static void Create();
  459.         static void Destroy();

  461.         static void DrawBattleGround();

  463.         static int GetScreenWidth();
  464.         static int GetScreenHeight();

  466.         static Rect GetBattleGround();

  468.         static void ShowScore();
  469.         static void ShowGameLevel(int nLevel);

  471.         static void ShowGameOver();

  473. private:
  474.         static Rect m_rectScreen;
  475.         static Rect m_rectBattleGround;

  477.         static char m_pArray[100];
  478. };

  480. #endif
  481. Graphic.cpp
  482. #include "Graphic.h"

  484. #include "Setting.h"

  486. Rect Graphic::m_rectScreen;
  487. Rect Graphic::m_rectBattleGround;
  488. char Graphic::m_pArray[100];

  490. void Graphic::Create()
  491. {
  492.         m_rectScreen.Set(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
  493.         initgraph(SCREEN_WIDTH, SCREEN_HEIGHT);
  494.         setbkcolor(DARKGRAY);

  496.         m_rectBattleGround.Set(BATTLE_GROUND_X1, BATTLE_GROUND_Y1, BATTLE_GROUND_X2, BATTLE_GROUND_Y2);
  497. }

  499. void Graphic::Destroy()
  500. {
  501.         closegraph();
  502. }

  504. void Graphic::DrawBattleGround()
  505. {
  506.         rectangle(m_rectBattleGround.GetStartPoint().GetX(), m_rectBattleGround.GetStartPoint().GetY(),
  507.                 m_rectBattleGround.GetEndPoint().GetX(), m_rectBattleGround.GetEndPoint().GetY());
  508. }

  510. int Graphic::GetScreenWidth()
  511. {
  512.         return SCREEN_WIDTH;
  513. }

  515. int Graphic::GetScreenHeight()
  516. {
  517.         return SCREEN_HEIGHT;
  518. }

  520. Rect Graphic::GetBattleGround()
  521. {
  522.         return m_rectBattleGround;
  523. }

  525. const int SCORE_LEFT = 810;
  526. const int SCORE_TOP = 5;

  528. void Graphic::ShowScore()
  529. {
  530.         COLORREF fill_color_save = getfillcolor();
  531.         COLORREF color_save = getcolor();

  533.         rectangle(SCORE_LEFT, SCORE_TOP, SCORE_LEFT + 200, SCORE_TOP + 40);


  536.         RECT r = { SCORE_LEFT, SCORE_TOP, SCORE_LEFT + 200, SCORE_TOP + 40 };
  537.         wsprintf((LPWSTR)m_pArray, _T("第 %d 關(guān)"), Setting::GetGameLevel());
  538.         drawtext((LPWSTR)m_pArray, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

  540.         r.top += 50;
  541.         r.bottom += 50;
  542.         wsprintf((LPWSTR)m_pArray, _T("分  數(shù)  :  %d"), Setting::GetSumScore());
  543.         drawtext((LPWSTR)m_pArray, &r, DT_VCENTER | DT_SINGLELINE);

  545.         r.top += 50;
  546.         r.bottom += 50;
  547.         wsprintf((LPWSTR)m_pArray, _T("級  別  :  %d"), Setting::GetTankLevel());
  548.         drawtext((LPWSTR)m_pArray, &r, DT_VCENTER | DT_SINGLELINE);

  550.         r.top += 50;
  551.         r.bottom += 50;
  552.         wsprintf((LPWSTR)m_pArray, _T("生  命  :  %d"), Setting::GetLife());
  553.         drawtext((LPWSTR)m_pArray, &r, DT_VCENTER | DT_SINGLELINE);

  555.         r.top += 50;
  556.         r.bottom += 50;
  557.         wsprintf((LPWSTR)m_pArray, _T("敵人數(shù)  :  %d"), Setting::GetTankNum());
  558.         drawtext((LPWSTR)m_pArray, &r, DT_VCENTER | DT_SINGLELINE);

  560.         r.top += 50;
  561.         r.bottom += 50;

  563.         line(SCORE_LEFT, r.bottom, SCREEN_WIDTH - 5, r.bottom);

  565.         r.top += 50;
  566.         r.bottom += 50;
  567.         wsprintf((LPWSTR)m_pArray, _T("共擊毀敵人數(shù)  :  %d"), Setting::GetTankSum());
  568.         drawtext((LPWSTR)m_pArray, &r, DT_VCENTER | DT_SINGLELINE);


  571.         setcolor(color_save);
  572.         setfillcolor(fill_color_save);
  573. }

  575. void Graphic::ShowGameLevel(int nLevel)
  576. {
  577.         COLORREF fill_color_save = getfillcolor();
  578.         COLORREF color_save = getcolor();

  580.         rectangle(BATTLE_GROUND_X1 + 100, BATTLE_GROUND_Y1 + 200, BATTLE_GROUND_X1 + 700, BATTLE_GROUND_Y1 + 380);

  582.         LOGFONT fontBak;
  583.         gettextstyle(&fontBak);               // 獲取當前字體設(shè)置

  585.         LOGFONT f = fontBak;
  586.         f.lfHeight = 48;                      // 設(shè)置字體高度為 48
  587.         _tcscpy_s(f.lfFaceName, _T("黑體"));  // 設(shè)置字體為“黑體”
  588.         f.lfQuality = ANTIALIASED_QUALITY;    // 設(shè)置輸出效果為抗鋸齒  
  589.         settextstyle(&f);                     // 設(shè)置字體樣式
  590.         wsprintf((LPWSTR)m_pArray, _T("第 %d 關(guān)"), nLevel);
  591.         outtextxy(BATTLE_GROUND_X1 + 300, BATTLE_GROUND_Y1 + 250, (LPWSTR)m_pArray);

  593.         f.lfHeight = 18;
  594.         settextstyle(&f);
  595.         wsprintf((LPWSTR)m_pArray, _T("按 Enter 鍵開始"), nLevel);
  596.         outtextxy(BATTLE_GROUND_X1 + 550, BATTLE_GROUND_Y1 + 350, (LPWSTR)m_pArray);

  598.         settextstyle(&fontBak);

  600.         setcolor(color_save);
  601.         setfillcolor(fill_color_save);
  602. }

  604. void Graphic::ShowGameOver()
  605. {
  606.         COLORREF fill_color_save = getfillcolor();
  607.         COLORREF color_save = getcolor();

  609.         rectangle(BATTLE_GROUND_X1 + 100, BATTLE_GROUND_Y1 + 200, BATTLE_GROUND_X1 + 700, BATTLE_GROUND_Y1 + 380);

  611.         LOGFONT fontBak;
  612.         gettextstyle(&fontBak);               // 獲取當前字體設(shè)置

  614.         LOGFONT f = fontBak;
  615.         f.lfHeight = 48;                      // 設(shè)置字體高度為 48
  616.         _tcscpy_s(f.lfFaceName, _T("黑體"));  // 設(shè)置字體為“黑體”
  617.         f.lfQuality = ANTIALIASED_QUALITY;    // 設(shè)置輸出效果為抗鋸齒  
  618.         settextstyle(&f);                     // 設(shè)置字體樣式
  619.         wsprintf((LPWSTR)m_pArray, _T("GAME OVER"));
  620.         outtextxy(BATTLE_GROUND_X1 + 300, BATTLE_GROUND_Y1 + 250, (LPWSTR)m_pArray);

  622.         f.lfHeight = 18;
  623.         settextstyle(&f);
  624.         wsprintf((LPWSTR)m_pArray, _T("按 Enter 鍵退出"));
  625.         outtextxy(BATTLE_GROUND_X1 + 550, BATTLE_GROUND_Y1 + 350, (LPWSTR)m_pArray);

  627.         settextstyle(&fontBak);

  629.         setcolor(color_save);
  630.         setfillcolor(fill_color_save);
  631. }
  632. Main.cpp
  633. #pragma warning(disable:4996)

  635. #include <iostream>
  636. #include <conio.h>
  637. #include <time.h>

  639. #include <list>

  641. #include "Graphic.h"
  642. #include "MainTank.h"
  643. #include "EnemyTank.h"
  644. #include "Utils/Shape.h"
  645. #include "Setting.h"

  647. using namespace std;

  649. MainTank mainTank;

  651. // Bullet list
  652. list<Object*> lstMainTankBullets;
  653. list<Object*> lstBullets;

  655. // Bomb List
  656. list<Object*> lstBombs;

  658. // Tank list
  659. list<Tank*> lstTanks;

  661. void CheckCrash()
  662. {
  663.         // Check enermy tank damage
  664.         for (list<Object*>::iterator it = lstMainTankBullets.begin(); it != lstMainTankBullets.end(); it++)
  665.         {
  666.                 for (list<Tank*>::iterator itt = lstTanks.begin(); itt != lstTanks.end(); itt++)
  667.                 {
  668.                         if (Shape::CheckIntersect((*it)->GetSphere(), (*itt)->GetSphere()))
  669.                         {
  670.                                 (*itt)->SetDisappear();
  671.                                 (*it)->SetDisappear();
  672.                         }
  673.                 }
  674.         }

  676.         // Check main tank damage
  677.         for (list<Object*>::iterator it = lstBullets.begin(); it != lstBullets.end(); it++)
  678.         {
  679.                 if (Shape::CheckIntersect((*it)->GetSphere(), mainTank.GetSphere()))
  680.                 {
  681.                         Setting::Die();

  683.                         if (Setting::GetLife() > 0)
  684.                         {
  685.                                 (*it)->SetDisappear();
  686.                         }
  687.                         else
  688.                         {
  689.                                 mainTank.SetDisappear();
  690.                         }                        
  691.                 }
  692.         }
  693. }

  695. void Init()
  696. {
  697.         srand((unsigned)time(NULL));

  699.         Graphic::Create();
  700.         
  701.         lstMainTankBullets.clear();
  702.         lstBullets.clear();
  703.         lstBombs.clear();
  704.         lstTanks.clear();
  705. }

  707. void Dispose()
  708. {
  709.         for (list<Tank*>::iterator it = lstTanks.begin(); it != lstTanks.end(); it++)
  710.         {
  711.                 delete *it;
  712.         }
  713.         lstTanks.clear();

  715.         for (list<Object*>::iterator it = lstMainTankBullets.begin(); it != lstMainTankBullets.end(); it++)
  716.         {
  717.                 delete *it;
  718.         }

  720.         for (list<Object*>::iterator it = lstBullets.begin(); it != lstBullets.end(); it++)
  721.         {
  722.                 delete *it;
  723.         }
  724.         lstBullets.clear();

  726.         for (list<Object*>::iterator it = lstBombs.begin(); it != lstBombs.end(); it++)
  727.         {
  728.                 delete *it;
  729.         }
  730.         lstBombs.clear();

  732.         Graphic::Destroy();
  733. }

  735. void main()
  736. {
  737.         Init();

  739.         bool loop = true;
  740.         bool skip = false;
  741.         bool bGameOver = false;
  742.         while (loop)
  743.         {
  744.                 if (kbhit())
  745.                 {
  746.                          int key = getch();
  747.                         if (skip && key != 13)
  748.                         {
  749.                                 continue;
  750.                         }

  752.                         Dir dirBak;
  753.                         switch (key)
  754.                         {
  755.                         // Up
  756.                         case 72:
  757.                                 mainTank.SetDir(Dir::UP);
  758.                                 break;
  759.                         // Down
  760.                         case 80:
  761.                                 mainTank.SetDir(Dir::DOWN);
  762.                                 break;
  763.                         // Left
  764.                         case 75:
  765.                                 mainTank.SetDir(Dir::LEFT);
  766.                                 break;
  767.                         // Right
  768.                         case 77:
  769.                                 mainTank.SetDir(Dir::RIGHT);
  770.                                 break;
  771.                         case 224: // 方向鍵高8位
  772.                                 break;
  773.                         // Esc
  774.                         case 27:
  775.                                 loop = false;
  776.                                 break;
  777.                         // Space
  778.                         case 32:
  779.                                 mainTank.Shoot(lstMainTankBullets);
  780.                                 break;
  781.                         // Q
  782.                         case 113:
  783.                                 dirBak = mainTank.GetDir();
  784.                                 mainTank.SetDir(Dir::UP);
  785.                                 mainTank.Shoot(lstMainTankBullets);
  786.                                 mainTank.SetDir(Dir::DOWN);
  787.                                 mainTank.Shoot(lstMainTankBullets);
  788.                                 mainTank.SetDir(Dir::LEFT);
  789.                                 mainTank.Shoot(lstMainTankBullets);
  790.                                 mainTank.SetDir(Dir::RIGHT);
  791.                                 mainTank.Shoot(lstMainTankBullets);
  792.                                 mainTank.SetDir(dirBak);
  793.                                 break;
  794.                         // Enter
  795.                         case 13:
  796.                                 if (skip)
  797.                                         skip = false;
  798.                                 else
  799.                                         skip = true;
  800.                                 break;
  801.                         default:
  802.                                 break;
  803.                         }
  804.                 }
  805.                
  806.                 if (!skip)
  807.                 {
  808.                         if (bGameOver)
  809.                         {
  810.                                 break;
  811.                         }

  813.                         // Draw Background
  814.                         cleardevice();
  815.                         Graphic::DrawBattleGround();
  816.                         
  817.                         CheckCrash();

  819.                         Graphic::ShowScore();

  821.                         // New Game Level
  822.                         if (Setting::m_bNewLevel)
  823.                         {
  824.                                 Setting::m_bNewLevel = false;

  826.                                 Setting::NewGameLevel();

  828.                                 Graphic::ShowGameLevel(Setting::GetGameLevel());

  830.                                 for (int i = 0; i < Setting::GetTankNum(); i++)
  831.                                 {
  832.                                         EnemyTank* p = new EnemyTank();
  833.                                         lstTanks.push_back(p);
  834.                                 }

  836.                                 // 設(shè)置暫停，按Enter開始
  837.                                 skip = true;
  838.                                 continue;
  839.                         }
  840.                                        
  841.                         if (mainTank.IsDisappear())
  842.                         {
  843.                                 skip = true;
  844.                                 bGameOver = true;

  846.                                 Graphic::ShowGameOver();

  848.                                 continue;
  849.                         }

  851.                         mainTank.Move();
  852.                         mainTank.Display();

  854.                         /* Draw Tanks */
  855.                         for (list<Tank*>::iterator it = lstTanks.begin(); it != lstTanks.end();)
  856.                         {
  857.                                 (*it)->Move();

  859.                                 if ((*it)->IsDisappear())
  860.                                 {
  861.                                         Setting::TankDamaged();

  863.                                         // Add a bomb
  864.                                         (*it)->Boom(lstBombs);

  866.                                         // Delete the tank
  867.                                         delete *it;
  868.                                         it = lstTanks.erase(it);
  869.                                         continue;
  870.                                 }

  872.                                 (*it)->Display();

  874.                                 if ((*it)->NeedShoot())
  875.                                 {
  876.                                         EnemyTank* p = (EnemyTank*)*it;
  877.                                         p->Shoot(lstBullets);
  878.                                 }
  879.                                 it++;
  880.                         }

  882.                         /* Draw Bullets */
  883.                         for (list<Object*>::iterator it = lstMainTankBullets.begin(); it != lstMainTankBullets.end();)
  884.                         {
  885.                                 (*it)->Move();

  887.                                 if ((*it)->IsDisappear())
  888.                                 {
  889.                                         // Add a bomb
  890.                                         (*it)->Boom(lstBombs);

  892.                                         // Delete the bullet
  893.                                         delete *it;
  894.                                         it = lstMainTankBullets.erase(it);
  895.                                         continue;
  896.                                 }

  898.                                 (*it)->Display();
  899.                                 it++;
  900.                         }

  902.                         for (list<Object*>::iterator it = lstBullets.begin(); it != lstBullets.end();)
  903.                         {
  904.                                 (*it)->Move();
  905.                         
  906.                                 if ((*it)->IsDisappear())
  907.                                 {
  908.                                         // Add a bomb
  909.                                         (*it)->Boom(lstBombs);

  911.                                         // Delete the bullet
  912.                                         delete *it;
  913.                                         it = lstBullets.erase(it);
  914.                                         continue;
  915.                                 }

  917.                                 (*it)->Display();
  918.                                 it++;
  919.                         }

  921.                         /* Draw Bombs */
  922.                         for (list<Object*>::iterator it = lstBombs.begin(); it != lstBombs.end();)
  923.                         {
  924.                                 (*it)->Move();

  926.                                 if ((*it)->IsDisappear())
  927.                                 {
  928.                                         delete *it;
  929.                                         it = lstBombs.erase(it);
  930.                                         continue;
  931.                                 }
  932.                                 
  933.                                 (*it)->Display();
  934.                                 it++;
  935.                         }
  936.                 }

  938.                 Sleep(100);
  939.         }
  940.         
  941.         // Destroy
  942.         Dispose();
  943. }
  944. MainTank.h
  945. #ifndef __MAIN_TANK__
  946. #define __MAIN_TANK__

  948. #include "Tank.h"

  950. class MainTank : public Tank
  951. {
  952. public:
  953.         MainTank() : Tank()
  954.         {
  955.                 m_pos.Set(300, 300);

  957.                 this->CalculateSphere();

  959.                 m_color = YELLOW;
  960.                 m_dir = Dir::UP;
  961.                 m_step = 4;
  962.         }

  964.         ~MainTank(){}

  966.         void SetDir(Dir dir);
  967.         Dir GetDir()
  968.         {
  969.                 return m_dir;
  970.         }
  971.         void Display();
  972.         void Move();
  973.         void Shoot(list<Object*>& lstBullets);
  974.         void Boom(list<Object*>& lstBombs);

  976. protected:
  977.         void CalculateSphere();

  979.         // 繪制坦克主體
  980.         void DrawTankBody();
  981. };

  983. #endif
  984. MainTank.cpp
  985. #include "MainTank.h"

  987. #include "Bullet.h"

  989. void MainTank::SetDir(Dir dir)
  990. {
  991.         m_dir = dir;
  992. }

  994. void MainTank::DrawTankBody()
  995. {
  996.         fillrectangle(m_pos.GetX() - 6, m_pos.GetY() - 6, m_pos.GetX() + 6, m_pos.GetY() + 6);

  998.         switch (m_dir)
  999.         {
  1000.         case UP:
  1001.         case DOWN:
  1002.                 fillrectangle(m_rectSphere.GetStartPoint().GetX(), m_rectSphere.GetStartPoint().GetY(),
  1003.                         m_rectSphere.GetStartPoint().GetX() + 4, m_rectSphere.GetEndPoint().GetY());
  1004.                 fillrectangle(m_rectSphere.GetEndPoint().GetX() - 4, m_rectSphere.GetStartPoint().GetY(),
  1005.                         m_rectSphere.GetEndPoint().GetX(), m_rectSphere.GetEndPoint().GetY());
  1006.                 break;
  1007.         case LEFT:
  1008.         case RIGHT:
  1009.                 fillrectangle(m_rectSphere.GetStartPoint().GetX(), m_rectSphere.GetStartPoint().GetY(),
  1010.                         m_rectSphere.GetEndPoint().GetX(), m_rectSphere.GetStartPoint().GetY() + 4);
  1011.                 fillrectangle(m_rectSphere.GetStartPoint().GetX(), m_rectSphere.GetEndPoint().GetY() - 4,
  1012.                         m_rectSphere.GetEndPoint().GetX(), m_rectSphere.GetEndPoint().GetY());
  1013.                 break;
  1014.         default:
  1015.                 break;
  1016.         }
  1017. }

  1019. void MainTank::Display()
  1020. {
  1021.         COLORREF fill_color_save = getfillcolor();
  1022.         COLORREF color_save = getcolor();

  1024.         setfillcolor(m_color);
  1025.         setcolor(m_color);

  1027.         DrawTankBody();

  1029.         switch (m_dir)
  1030.         {
  1031.         case UP:
  1032.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX(), m_pos.GetY() - 15);
  1033.                 break;
  1034.         case DOWN:
  1035.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX(), m_pos.GetY() + 15);
  1036.                 break;
  1037.         case LEFT:
  1038.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX() - 15, m_pos.GetY());
  1039.                 break;
  1040.         case RIGHT:
  1041.                 line(m_pos.GetX(), m_pos.GetY(), m_pos.GetX() + 15, m_pos.GetY());
  1042.                 break;
  1043.         default:
  1044.                 break;
  1045.         }

  1047.         setcolor(color_save);
  1048.         setfillcolor(fill_color_save);
  1049. }

  1051. void MainTank::Move()
  1052. {
  1053.         switch (m_dir)
  1054.         {
  1055.         case UP:
  1056.                 m_pos.SetY(m_pos.GetY() - m_step);
  1057.                 if (m_rectSphere.GetStartPoint().GetY() < Graphic::GetBattleGround().GetStartPoint().GetY())
  1058.                         m_pos.SetY(m_pos.GetY() + m_step);
  1059.                 break;
  1060.         case DOWN:
  1061.                 m_pos.SetY(m_pos.GetY() + m_step);
  1062.                 if (m_rectSphere.GetEndPoint().GetY() > Graphic::GetBattleGround().GetEndPoint().GetY())
  1063.                         m_pos.SetY(m_pos.GetY() - m_step);
  1064.                 break;
  1065.         case LEFT:
  1066.                 m_pos.SetX(m_pos.GetX() - m_step);
  1067.                 if (m_rectSphere.GetStartPoint().GetX() < Graphic::GetBattleGround().GetStartPoint().GetX())
  1068.                         m_pos.SetX(m_pos.GetX() + m_step);
  1069.                 break;
  1070.         case RIGHT:
  1071.                 m_pos.SetX(m_pos.GetX() + m_step);
  1072.                 if (m_rectSphere.GetEndPoint().GetX() > Graphic::GetBattleGround().GetEndPoint().GetX())
  1073.                         m_pos.SetX(m_pos.GetX() - m_step);
  1074.                 break;
  1075.         default:
  1076.                 break;
  1077.         }

  1079.         CalculateSphere();
  1080. }

  1082. void MainTank::CalculateSphere()
  1083. {
  1084.         switch (m_dir)
  1085.         {
  1086.         case UP:
  1087.         case DOWN:
  1088.                 m_rectSphere.Set(m_pos.GetX() - 13, m_pos.GetY() - 10, m_pos.GetX() + 13, m_pos.GetY() + 10);
  1089.                 break;
  1090.         case LEFT:
  1091.         case RIGHT:
  1092.                 m_rectSphere.Set(m_pos.GetX() - 10, m_pos.GetY() - 13, m_pos.GetX() + 10, m_pos.GetY() + 13);
  1093.                 break;
  1094.         default:
  1095.                 break;
  1096.         }
  1097. }

  1099. void MainTank::Shoot(list<Object*>& lstBullets)
  1100. {
  1101.         Bullet* pBullet = new Bullet(m_pos, m_dir, m_color);
  1102.         pBullet->SetStep(20);

  1104.         lstBullets.push_back(pBullet);
  1105. }

  1107. void MainTank::Boom(list<Object*>& lstBombs)
  1108. {

  1110. }
  1111. Object.h
  1112. #ifndef __OBJECT_H__
  1113. #define __OBJECT_H__

  1115. #include <list>

  1117. #include "Graphic.h"

  1119. using namespace std;

  1121. enum Dir { UP, DOWN, LEFT, RIGHT };

  1123. class Object
  1124. {
  1125. public:
  1126.         // 繪圖
  1127.         virtual void Display() = 0;

  1129.         // 移動
  1130.         virtual void Move() = 0;

  1132.         // 爆炸
  1133.         virtual void Boom(list<Object*>& lstBombs) = 0;

  1135.         // 設(shè)置消失
  1136.         virtual void SetDisappear() = 0;

  1138.         // 判斷是否消失
  1139.         virtual bool IsDisappear() = 0;

  1141.         virtual Rect GetSphere() = 0;

  1143. protected:
  1144.         // 計算勢力范圍
  1145.         virtual void CalculateSphere() = 0;

  1147.         // 位置
  1148.         Point m_pos;

  1150.         // 勢力范圍
  1151.         Rect m_rectSphere;

  1153.         // 顏色
  1154.         COLORREF m_color;
  1155.         // 方向
  1156.         Dir m_dir;
  1157.         // 存在狀態(tài)
  1158.         bool m_bDisappear;
  1159.         // 單次前進步長
  1160.         int m_step;
  1161. };

  1163. #endif
  1164. Point.cpp
  1165. #include "Point.h"

  1167. void Point::Set(int x, int y)
  1168. {
  1169.         m_x = x;
  1170.         m_y = y;
  1171. }

  1173. void Point::SetX(int x)
  1174. {
  1175.         m_x = x;
  1176. }

  1178. void Point::SetY(int y)
  1179. {
  1180.         m_y = y;
  1181. }

  1183. int Point::GetX() const
  1184. {
  1185.         return m_x;
  1186. }

  1188. int Point::GetY() const
  1189. {
  1190.         return m_y;
  1191. }
  1192. Point.h
  1193. #ifndef __POINT_H__
  1194. #define __POINT_H__

  1196. class Point
  1197. {
  1198. public:
  1199.         Point(int x = 0, int y = 0) : m_x(x), m_y(y){};
  1200.         ~Point(){};

  1202.         Point& operator=(const Point &p)
  1203.         {
  1204.                 m_x = p.m_x;
  1205.                 m_y = p.m_y;

  1207.                 return *this;
  1208.         }

  1210.         void Set(int x, int y);

  1212.         void SetX(int x);
  1213.         void SetY(int y);

  1215.         int GetX() const;
  1216.         int GetY() const;

  1218. private:
  1219.         int m_x;
  1220.         int m_y;
  1221. };

  1223. #endif
  1224. Rect.h
  1225. #ifndef __RECTANGLE_H__
  1226. #define __RECTANGLE_H__

  1228. #include "Point.h"

  1230. class Rect
  1231. {
  1232. public:
  1233.         Rect(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : m_startPoint(x1, y1), m_endPoint(x2, y2){}
  1234.         Rect(const Point p1, const Point p2) : m_startPoint(p1), m_endPoint(p2){}
  1235.         Rect(const Rect& r1) : m_startPoint(r1.GetStartPoint()), m_endPoint(r1.GetEndPoint()){}
  1236.         ~Rect(){};

  1238.         Rect& operator=(const Rect &rect)
  1239.         {
  1240.                 m_startPoint = rect.GetStartPoint();
  1241.                 m_endPoint = rect.GetEndPoint();

  1243.                 return *this;
  1244.         }

  1246.         void Set(const Point pStart, const Point pEnd);
  1247.         void Set(int x1, int y1, int x2, int y2);

  1249.         void SetStartPoint(const Point p);
  1250.         void SetEndPoint(const Point p);

  1252.         Point GetStartPoint() const;
  1253.         Point GetEndPoint() const;

  1255.         Point GetTRPoint() const; // Get Top Right Point
  1256.         Point GetBLPoint() const; // Get Bottom Left Point

  1258.         int GetWidth();
  1259.         int GetHeight();


  1262. private:
  1263.         void Check();

  1265.         Point m_startPoint;
  1266.         Point m_endPoint;
  1267. };

  1269. #endif
  1270. Setting.cpp
  1271. #include "Setting.h"

  1273. bool Setting::m_bNewLevel = true;

  1275. int Setting::m_nLife = 3;

  1277. int Setting::m_nGameLevel = 0;
  1278. int Setting::m_nTankLevel = 1;

  1280. int Setting::m_nTankNum = 5;

  1282. int Setting::m_nSumScore = 0;

  1284. int Setting::m_nTankScore = 5;

  1286. int Setting::m_nTankSum = 0;

  1288. void Setting::NewGameLevel()
  1289. {
  1290.         m_nGameLevel++;

  1292.         m_nTankNum = 10 + 5 * (m_nGameLevel - 1);
  1293.         m_nTankScore += 5;
  1294. }

  1296. void Setting::TankDamaged()
  1297. {
  1298.         m_nTankNum--;
  1299.         m_nSumScore += m_nTankScore;

  1301.         m_nTankLevel = m_nSumScore / 150 + 1;

  1303.         if (m_nSumScore % 500 < m_nTankScore)
  1304.         {
  1305.                 m_nLife++;
  1306.         }

  1308.         m_nTankSum++;

  1310.         if (m_nTankNum == 0)
  1311.         {
  1312.                 m_bNewLevel = true;
  1313.         }
  1314. }
  1315. Setting.h
  1316. #ifndef __SETTING_H__
  1317. #define __SETTING_H__

  1319. #include <list>

  1321. using namespace std;

  1323. class Setting
  1324. {
  1325. public:
  1326.         static void NewGameLevel();
  1327.         static void TankDamaged();

  1329.         static int GetLife()
  1330.         {
  1331.                 return m_nLife;
  1332.         }

  1334.         static void Die()
  1335.         {
  1336.                 m_nLife -= 1;
  1337.         }

  1339.         static int GetGameLevel()
  1340.         {
  1341.                 return m_nGameLevel;
  1342.         }

  1344.         static int GetTankLevel()
  1345.         {
  1346.                 return m_nTankLevel;
  1347.         }

  1349.         static int GetTankNum()
  1350.         {
  1351.                 return m_nTankNum;
  1352.         }

  1354.         static int GetSumScore()
  1355. ……………………

  1357. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復制代碼

所有資料51hei提供下載:
坦克大戰(zhàn).zip (5.63 KB, 下載次數(shù): 77)


評分

參與人數(shù) 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏2 分享淘帖 頂頂 踩踩
回復

使用道具 舉報

沙發(fā)
ID:329253 發(fā)表于 2018-7-9 15:13 來自手機 | 只看該作者
厲害厲害
回復

使用道具 舉報

板凳
ID:345773 發(fā)表于 2018-7-10 15:04 | 只看該作者
怎么在vc6++里面運行報錯呢
回復

使用道具 舉報

地板
ID:380546 發(fā)表于 2018-10-30 16:37 | 只看該作者
報錯啊怎么。。
回復

使用道具 舉報

5#
ID:411024 發(fā)表于 2018-11-2 16:10 | 只看該作者
最好做移動端吧！很少看到在PC端玩游戲了！
回復

使用道具 舉報

6#
ID:481812 發(fā)表于 2019-2-27 21:09 | 只看該作者
74LS161 發(fā)表于 2018-7-10 15:04
怎么在vc6++里面運行報錯呢

語法錯誤 你自己找找錯誤在哪里
回復

使用道具 舉報

7#
ID:617948 發(fā)表于 2019-9-29 12:28 | 只看該作者
好編程 不錯
回復

使用道具 舉報

8#
ID:618406 發(fā)表于 2019-10-4 15:21 | 只看該作者
不給源文件怎么運行啊
回復

使用道具 舉報

9#
ID:623961 發(fā)表于 2019-10-14 16:59 | 只看該作者
報錯是什么情況
回復

使用道具 舉報

10#
ID:762010 發(fā)表于 2020-5-26 22:04 | 只看該作者
報錯是什么情況
報錯是什么情況
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機教程網(wǎng)

快速回復 返回頂部 返回列表