自己動手寫游戲：坦克撕逼大戰

START：最近在公交車上無聊，於是用平板看了看下載的坦克大戰的開發教程，於是在晚上回家后花了兩天模仿了一個，現在來總結一下。

一、關於坦克大戰

　　《坦克大戰》（Battle City）是1985年日本南夢宮Namco游戲公司開發並且在任天堂FC平台上，推出的一款多方位平面射擊游戲。游戲以坦克戰斗及保衛基地為主題，屬於策略型聯機類。同時也是FC平台上少有的內建關卡編輯器的幾個游戲之一，玩家可自己創建獨特的關卡，並通過獲取一些道具使坦克和基地得到強化。

　　1985年推出的坦克大戰（Battle City）由13×13大小的地圖組成了35個關卡，地形包括磚牆、海水、鋼板、森林、地板5種，玩家作為坦克軍團僅存的一支精銳部隊的指揮官，為了保衛基地不被摧毀而展開戰斗。游戲中可以獲取有多種功能的寶物，敵人種類則包括裝甲車、輕型坦克、反坦克炮、重型坦克4種，且存在炮彈互相抵消和友軍火力誤傷的設定。

　　1990年推出的坦克大戰較原版而言，可以選擇14種規則進行游戲（Tank A-Tank N），且敵方坦克增加了護甲，也能通過寶物讓我方陷入不利局面。寶物當中增加了能通過海水或樹林的特性。全部關卡為50關。

二、關於游戲設計

2.1 總結游戲印象

　　我相信坦克大戰一定是大部分80后童鞋兒時的經典，現在我們拉看看這款游戲的經典之處：

　　（1）一個玩家坦克，多個電腦坦克

　　① 　　② 　　③ 　　④

　　（2）玩家可以發子彈，電腦坦克也可以發子彈

　　①　　②

　　（3）電腦坦克被擊中后有爆炸效果，並且有一定幾率出現游戲道具

　　①　　②　　③

2.2 總結設計思路

　　（1）萬物皆對象

　　在整個游戲中，我們看到的所有內容，我們都可以理解為游戲對象（GameObject），每一個游戲對象，都由一個單獨的類來創建；在游戲中主要有三類游戲對象：一是坦克，二是子彈，三是道具；其中，坦克又分為玩家坦克和電腦坦克，子彈又分為玩家子彈和電腦子彈。於是，我們可以對坦克進行抽象形成一個抽象父類：TankFather，然后分別創建兩個子類：PlayerTank和EnemyTank；然后對子彈進行抽象形成一個抽象類：BulletFather，然后分別創建兩個子類：PlayerBullet和EnemyBullet。但是，我們發現這些游戲對象都有一些共同的屬性和方法，例如X，Y軸坐標，長度和寬度，以及繪制（Draw()）和移動（Move()）的方法，這時我們可以設計一個抽象類，形成了GameObject類：將共有的東西封裝起來，減少開發時的冗余代碼，提高程序的可擴展性，符合面向對象設計的思路：

　　（2）計划生育好

　　在整個游戲中，我們的玩家坦克對象只有一個，也就是說在內存中只需要存一份即可。這時，我們想到了偉大的計划生育政策，於是我們想到了使用單例模式。借助單例模式，可以保證只生成一個玩家坦克的實例，即為程序提供一個全局訪問點，避免重復創建浪費不必要的內存。當然，除了玩家坦克外，我們的電腦坦克集合、子彈集合等集合對象實例也保證只有一份存儲，降低游戲開銷；

　　（3）對象的運動

　　在整個游戲過程中，玩家可以通過鍵盤上下左右鍵控制玩家坦克的上下左右運動，而坦克的運動本質上還是改變游戲對象的X軸和Y軸的坐標，然后一直不間斷地在窗體上重繪游戲對象。相比玩家坦克的移動，電腦坦克的移動則完全是通過程序中設置的隨機函數控制上下左右實現的，而坦克們發出的子彈執行的運動則是從上到下或從下到上，從左到右或從右到左。

　　（4）設計流程圖

三、關鍵代碼實現

3.1 設計抽象父類封裝共有屬性

    /// <summary>
    /// 所有游戲對象的基類
   /// </summary>
    public abstract class GameObject
    {
        #region 游戲對象的屬性
        public int X
        {
            get;
            set;
        }

        public int Y
        {
            get;
            set;
        }

        public int Width
        {
            get;
            set;
        }

        public int Height
        {
            get;
            set;
        }

        public int Speed
        {
            get;
            set;
        }

        public int Life
        {
            get;
            set;
        }


        public Direction Dir
        {
            get;
            set;
        }
        #endregion

        #region 初始化游戲對象
        public GameObject(int x, int y, int width, int height,
                int speed, int life, Direction dir)
        {
            this.X = x;
            this.Y = y;
            this.Width = width;
            this.Height = height;
            this.Speed = speed;
            this.Life = life;
            this.Dir = dir;
        }

        public GameObject(int x, int y)
            : this(x, y, 0, 0, 0, 0, 0)
        {

        }

        public GameObject(int x, int y, int width, int height)
            : this(x, y, width, height, 0, 0, 0)
        {

        }
        #endregion

        #region 游戲對象公有方法
        /// <summary>
        /// 抽象方法：繪制自身
        /// </summary>
        /// <param name="g"></param>
        public abstract void Draw(Graphics g);

        /// <summary>
        /// 虛方法：移動自身
        /// </summary>
        public virtual void Move()
        {
            switch (this.Dir)
            {
                case Direction.Up:
                    this.Y -= this.Speed;
                    break;
                case Direction.Down:
                    this.Y += this.Speed;
                    break;
                case Direction.Left:
                    this.X -= this.Speed;
                    break;
                case Direction.Right:
                    this.X += this.Speed;
                    break;
            }
            // 在游戲對象移動完成后判斷一下:當前游戲對象是否超出當前的窗體 
            if (this.X <= 0)
            {
                this.X = 0;
            }
            if (this.Y <= 0)
            {
                this.Y = 0;
            }
            if (this.X >= 720)
            {
                this.X = 720;
            }
            if (this.Y >= 580)
            {
                this.Y = 580;
            }
        }

        /// <summary>
        /// 獲取所在區域，用於碰撞檢測
      /// </summary>
        /// <returns>矩形區域</returns>
        public Rectangle GetRectangle()
        {
            return new Rectangle(this.X, this.Y, this.Width, this.Height);
        }
        #endregion
    }

　　一切皆對象，這里封裝了游戲對象坦克和子彈以及其他游戲對象共有的屬性，以及兩個抽象方法，讓對象們（坦克？子彈？爆炸效果？出現效果？）自己去實現。

3.2 設計單例模式減少對象創建

    /// <summary>
    /// 單例游戲對象類
   /// </summary>
    public class SingleObject
    {
        private SingleObject()
        { }

        private static SingleObject _singleObject = null;

        public static SingleObject GetInstance()
        {
            if (_singleObject == null)
            {
                _singleObject = new SingleObject();
            }
            return _singleObject;
        }

        /// <summary>
        /// 玩家坦克單一實例
        /// </summary>
        public PlayerTank Player
        {
            get;
            set;
        }
        /// <summary>
        /// 電腦坦克集合單一實例
        /// </summary>
        public List<EnemyTank> EnemyList
        {
            get;
            set;
        }
        /// <summary>
        /// 玩家坦克子彈對象集合單一實例
        /// </summary>
        public List<PlayerBullet> PlayerBulletList
        {
            get;
            set;
        }
        /// <summary>
        /// 電腦坦克子彈對象集合單一實例
        /// </summary>
        public List<EnemyBullet> EnemyBulletList
        {
            get;
            set;
        }
        /// <summary>
        /// 爆炸效果對象集合單一實例
        /// </summary>
        public List<Boom> BoomImageList
        {
            get;
            set;
        }
        /// <summary>
        /// 閃爍圖片效果集合單一實例
        /// </summary>
        public List<TankBorn> TankBornList
        {
            get;
            set;
        }
        /// <summary>
        /// 游戲道具集合單一實例
        /// </summary>
        public List<Prop> PropList
        {
            get;
            set;
        }

        /// <summary>
        /// 新增游戲對象
        /// </summary>
        /// <param name="go">游戲對象</param>
        public void AddGameObject(GameObject go)
        {
            if (go is PlayerTank)
            {
                this.Player = go as PlayerTank;
            }
            else if (go is EnemyTank)
            {
                if (this.EnemyList == null)
                {
                    this.EnemyList = new List<EnemyTank>();
                }
                this.EnemyList.Add(go as EnemyTank);
            }
            else if (go is PlayerBullet)
            {
                if (this.PlayerBulletList == null)
                {
                    this.PlayerBulletList = new List<PlayerBullet>();
                }
                this.PlayerBulletList.Add(go as PlayerBullet);
            }
            else if (go is EnemyBullet)
            {
                if (this.EnemyBulletList == null)
                {
                    this.EnemyBulletList = new List<EnemyBullet>();
                }
                this.EnemyBulletList.Add(go as EnemyBullet);
            }
            else if (go is Boom)
            {
                if (this.BoomImageList == null)
                {
                    this.BoomImageList = new List<Boom>();
                }
                this.BoomImageList.Add(go as Boom);
            }
            else if (go is TankBorn)
            {
                if (this.TankBornList == null)
                {
                    this.TankBornList = new List<TankBorn>();
                }
                this.TankBornList.Add(go as TankBorn);
            }
            else if (go is Prop)
            {
                if (this.PropList == null)
                {
                    this.PropList = new List<Prop>();
                }
                this.PropList.Add(go as Prop);
            }
            else
            {
                return;
            }
        }

        /// <summary>
        /// 移除游戲對象
        /// </summary>
        /// <param name="go"></param>
        public void RemoveGameObject(GameObject go)
        {
            if (go is PlayerTank)
            {
                // 玩家被擊中后
            }
            else if (go is PlayerBullet)
            {
                PlayerBulletList.Remove(go as PlayerBullet);
            }
            else if (go is EnemyBullet)
            {
                EnemyBulletList.Remove(go as EnemyBullet);
            }
            else if (go is EnemyTank)
            {
                EnemyList.Remove(go as EnemyTank);
            }

            else if (go is Boom)
            {
                BoomImageList.Remove(go as Boom);
            }
            else if (go is TankBorn)
            {
                TankBornList.Remove(go as TankBorn);
            }
            else if (go is Prop)
            {
                PropList.Remove(go as Prop);
            }
            else
            {
                return;
            }
        }

        /// <summary>
        /// 繪制游戲對象
        /// </summary>
        /// <param name="g">繪圖圖面</param>
        public void Draw(Graphics g)
        {
            // Step1:繪制玩家坦克
         if(Player != null)
            {
                Player.Draw(g);
            }
            // Step2:繪制電腦坦克
         if(EnemyList != null)
            {
                for (int i = 0; i < EnemyList.Count; i++)
                {
                    EnemyList[i].Draw(g);
                }
            }
            // Step3:繪制子彈效果
         if (PlayerBulletList != null)
            {
                for (int i = 0; i < PlayerBulletList.Count; i++)
                {
                    PlayerBulletList[i].Draw(g);
                }
            }
            if (EnemyBulletList != null)
            {
                for (int i = 0; i < EnemyBulletList.Count; i++)
                {
                    EnemyBulletList[i].Draw(g);
                }
            }
            // Step4:繪制爆炸效果
         if (BoomImageList != null)
            {
                for (int i = 0; i < BoomImageList.Count; i++)
                {
                    BoomImageList[i].Draw(g);
                }
            }
            // Step5:繪制閃爍效果
         if (TankBornList != null)
            {
                for (int i = 0; i < TankBornList.Count; i++)
                {
                    TankBornList[i].Draw(g);
                }
            }
            // Step6:繪制游戲道具
         if (PropList != null)
            {
                for (int i = 0; i < PropList.Count; i++)
                {
                    PropList[i].Draw(g);
                }
            }
        }
    }

　　這里借助單例模式，保證玩家坦克只有一個存儲，電腦坦克集合也只有一個，而具體的電腦坦克對象則分別在集合中Add和Remove。

3.3 設計道具檢測方法使玩家能夠碉堡

　　（1）設計游戲道具類，為三種類型的道具設置一個標志屬性：

    /// <summary>
    /// 游戲道具類
   /// </summary>
    public class Prop : GameObject
    {
        private static Image imgStar = Resources.star;
        private static Image imgBomb = Resources.bomb;
        private static Image imgTimer = Resources.timer;

        /// <summary>
        /// 游戲道具類型：0-五角星，1-炸彈，2-定時器
      /// </summary>
        public int PropType
        {
            get;
            set;
        }

        public Prop(int x, int y, int propType)
            : base(x, y, imgStar.Width, imgStar.Height)
        {
            this.PropType = propType;
        }

        public override void Draw(System.Drawing.Graphics g)
        {
            switch(PropType)
            {
                case 0:
                    g.DrawImage(imgStar,this.X,this.Y);
                    break;
                case 1:
                    g.DrawImage(imgBomb, this.X, this.Y);
                    break;
                case 2:
                    g.DrawImage(imgTimer, this.X, this.Y);
                    break;
            }
        }
    }

　　（2）在單例類中創建一個判斷道具類型的方法，根據標志屬性區分不同道具，並進行對應的道具效果：

        /// <summary>
        /// 判斷游戲道具類型
      /// </summary>
        /// <param name="propType"></param>
        public void JudgePropType(int propType)
        {
            switch (propType)
            {
                case 0:// 吃到五角星讓玩家子彈速度變快
                    if (Player.BulletLevel < 2)
                    {
                        Player.BulletLevel++;
                    }
                    break;
                case 1:// 吃到炸彈讓一定區域內的電腦坦克爆炸
                    for (int i = 0; i < EnemyList.Count; i++)
                    {
                        // 把電腦坦克生命值設置為0
                        EnemyList[i].Life = 0;
                        EnemyList[i].IsOver();
                    }
                    break;
                case 2:// 吃到定時器讓所有坦克定住一段時間
                    for (int i = 0; i < EnemyList.Count; i++)
                    {
                        EnemyList[i].isPause = true;
                    }
                    break;
            }
        }

3.4 設計碰撞檢測方法使電腦坦克可以減少

　　（1）Rectangle的IntersectsWith方法

　　在游戲界面中，任何一個游戲對象我們都可以視為一個矩形區域（Rectangle類實例），它的坐標是X軸和Y軸，它還有長度和寬度，可以輕松地確定一個它所在的矩形區域。那么，我們可以通過Rectangle的IntersectsWith方法確定兩個Rectangle是否存在重疊，如果有重疊，此方法將返回 true；否則將返回 false。那么，在坦克大戰中主要是判斷兩種情況：一是玩家或電腦坦克發射的子彈是否擊中了對方？二是玩家是否吃到了游戲道具？

　　（2）在定時器事件中定期執行碰撞檢測方法

        /// <summary>
        /// 碰撞檢測
      /// </summary>
        public void CollisionDetection()
        {
            #region Step1:判斷玩家發射的子彈是否擊中了電腦坦克
            // Step1:判斷玩家發射的子彈是否擊中了電腦坦克
         if (PlayerBulletList != null)
            {
                for (int i = 0; i < PlayerBulletList.Count; i++)
                {
                    for (int j = 0; j < EnemyList.Count; j++)
                    {
                        if (PlayerBulletList[i].GetRectangle().IntersectsWith(EnemyList[j].GetRectangle()))
                        {
                            // 電腦坦克減少生命值
                            EnemyList[j].Life -= PlayerBulletList[i].Power;
                            EnemyList[j].IsOver();
                            // 移除子彈對象實例
                            PlayerBulletList.Remove(PlayerBulletList[i]);
                            break;
                        }
                    }
                }
            }
            #endregion

            #region Step2:判斷電腦發射的子彈是否擊中了玩家坦克
            // Step2:判斷電腦發射的子彈是否擊中了玩家坦克
         if (EnemyBulletList != null)
            {
                for (int i = 0; i < EnemyBulletList.Count; i++)
                {
                    if (EnemyBulletList[i].GetRectangle().IntersectsWith(Player.GetRectangle()))
                    {
                        // 玩家坦克減少生命值
                        Player.Life -= EnemyBulletList[i].Power;
                        Player.IsOver();
                        // 移除子彈對象實例
                        EnemyBulletList.Remove(EnemyBulletList[i]);
                    }
                }
            }
            #endregion

            #region Step3:判斷玩家是否吃到了游戲道具
            // Step3:判斷玩家是否吃到了游戲道具
         if (PropList != null)
            {
                for (int i = 0; i < PropList.Count; i++)
                {
                    if (PropList[i].GetRectangle().IntersectsWith(Player.GetRectangle()))
                    {
                        // 播放吃到道具音效
                        SoundPlayer sp = new SoundPlayer(Resources.add);
                        sp.Play();
                        // 增加子彈等級
                        JudgePropType(PropList[i].PropType);
                        // 移除游戲道具實例
                        PropList.Remove(PropList[i]);
                    }
                }
            }
            #endregion

            #region Step4:判斷電腦坦克是否和玩家坦克相撞
         if (EnemyList != null)
            {
                for (int i = 0; i < EnemyList.Count; i++)
                {
                    if (EnemyList[i].GetRectangle().IntersectsWith(Player.GetRectangle()))
                    {
                        switch (Player.Dir)
                        {
                            case Direction.Up:
                                EnemyList[i].Dir = Direction.Right;
                                break;
                            case Direction.Down:
                                EnemyList[i].Dir = Direction.Left;
                                break;
                            case Direction.Left:
                                EnemyList[i].Dir = Direction.Up;
                                break;
                            case Direction.Right:
                                EnemyList[i].Dir = Direction.Down;
                                break;
                        }
                    }
                }
            } 
            #endregion

            #region Step5:判斷電腦坦克A是否和電腦坦克B發生了碰撞
            // Step5:判斷電腦坦克A是否和電腦坦克B發生了碰撞
         if (EnemyList != null)
            {
                for (int i = 0; i < EnemyList.Count - 1; i++)
                {
                    for (int j = i + 1; j < EnemyList.Count; j++)
                    {
                        if (EnemyList[i].GetRectangle().IntersectsWith(EnemyList[j].GetRectangle()))
                        {
                            switch (EnemyList[i].Dir)
                            {
                                case Direction.Up:
                                    EnemyList[j].Dir = Direction.Right;
                                    break;
                                case Direction.Down:
                                    EnemyList[j].Dir = Direction.Left;
                                    break;
                                case Direction.Left:
                                    EnemyList[j].Dir = Direction.Up;
                                    break;
                                case Direction.Right:
                                    EnemyList[j].Dir = Direction.Down;
                                    break;
                            }
                        }
                    }
                }
            } 
            #endregion
        }

四、個人開發小結

　　從下面的運行效果可以看出，此次DEMO主要完成了幾個比較核心的內容：一是玩家坦克和電腦坦克的移動，二是玩家和電腦發射子彈，三是坦克和子彈的碰撞檢測。

　　當然，還有很多核心的內容沒有實現，比如：計算被擊中的電腦坦克數量、游戲歡迎界面和結束界面等。希望有興趣的童鞋可以去繼續完善實現，這里提供一個我的坦克大戰實現僅供參考，謝謝！

參考資料

　　趙建宇，《六小時C#開發搞定坦克大戰游戲》：http://bbs.itcast.cn/thread-28540-1-1.html

附件下載

　　MyTankGame：http://pan.baidu.com/s/1o6wUGae

 

作者：周旭龍

出處：http://www.cnblogs.com/edisonchou/

本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文鏈接。