• ??歡迎點贊 ?? 收藏 ?留言 ?? 如有錯誤敬請指正！
• ??本文由 God Y.原創??
• ??未來很長，值得我們全力奔赴更美好的生活?

炸彈人

??前言

• 本篇博客是寫了一篇很簡單的炸彈人游戲，讓你重拾童年的回憶~
• 時間實在是不夠用啦，擠牙膏搞出來這個炸彈人的小游戲，希望大家三連支持一下~
• 工程源碼在文章最后，感興趣的可以下載試玩，也可以自己嘗試制作一下玩哦~

• 大家小時候肯定玩過這款游戲，炸彈人也算是經典中的經典啦??~
• 希望看到這篇小游戲，可以讓你重拾童年跟小伙伴一起對著大屁股電視機玩游戲的美好時光??！
• 時間在慢慢的流逝，那些陪你一起度過童年的小伙伴有多久沒聯系了呢??~
• 看完這篇炸彈人，有時間的話就找自己童年的小伙伴們聊會天吧，一起找回童年的回憶和夢想??！

圖片.png

回歸主題，炸彈人小游戲制作開始！

??正文

來看一下炸彈人小游戲的效果吧！

20210621201904414.gif

??制作思路

老規矩，做之前我們先來整一下做這個小游戲的思路
讓我們動一下腦袋瓜想一下一個炸彈人小游戲里面都有什么東西呢

• 首先要有一個游戲場景，這個場景就是我們在游戲運行的時候，我們可以看到的地方

• 這個場景中會有許多墻體，其中四周會有一個游戲邊緣墻體，這些墻體是無法被我們的炸彈毀掉的，稱他為超級墻體！

• 場景里面也會有一些墻體，可以被摧毀，我們成為普通墻體~

• 有些是固定的，有些是可被摧毀的，這就是一個經典的炸彈人玩法了！

• 其次，我們要有一個主角，就是我們的炸彈人！

• 我們的主角可以上下左右移動，然后還可以"下蛋"，就是放炸彈，炸敵人

• 然后還要有血量等等

• 當然少不了敵人了，我們給場景中加入一個可以隨機左右移動的敵人，碰到我們之后就會讓我們掉血

• 這也是一個最經典而且基礎的玩法啦~

乍一想好像也就這么點東西，也不是很難的樣子

那我們現在就開始動手操作吧！

??開始制作

• 導入素材資源包

• 導入后，工程資源是這樣的

  
  
  圖片.png

其中有一些精靈圖片素材，為我們做主角、敵人和墻體時候使用

還有幾個簡單的聲音特效和動畫特效，為我們的游戲制作提供后勤支援！

第一步：游戲場景制作

• 我們是一個2D游戲，在這里的游戲場景中，地圖是精靈圖片做的

• 我們這里寫個腳本，讓他在游戲運行時，直接生成相應的地圖

• 這里是用了一個對象池腳本ObjectPool，用來拿到工程中所有的資源，然后需要使用的時候從對象池生成到場景中

• 這里就不多介紹對象池了，方法有很多種

• 這里提供一種作為參考，可直接掛到場景中使用即可

上代碼：

public enum ObjectType
{
    SuperWall,
    Wall,
    Prop,
    Bomb,
    Enemy,
    BombEffect
}
[System.Serializable]
public class Type_Prefab
{
    public ObjectType type;
    public GameObject prefab;
}

public class ObjectPool : MonoBehaviour
{
    public static ObjectPool Instance;
    public List<Type_Prefab> type_Prefabs = new List<Type_Prefab>();
    /// <summary>
    /// 通過物體類型獲取該預制體
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    private GameObject GetPreByType(ObjectType type)
    {
        foreach (var item in type_Prefabs)
        {
            if (item.type == type)
                return item.prefab;
        }
        return null;
    }
    /// <summary>
    /// 物體類型和對應的對象池關系字典
    /// </summary>
    private Dictionary<ObjectType, List<GameObject>> dic =
        new Dictionary<ObjectType, List<GameObject>>();

    private void Awake()
    {
        Instance = this;
    }
    /// <summary>
    /// 通過物體類型從相對應的對象池中取東西
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public GameObject Get(ObjectType type, Vector2 pos)
    {
        GameObject temp = null;
        //判斷字典中有沒有與該類型匹配的對象池，沒有則創建
        if (dic.ContainsKey(type) == false)
            dic.Add(type, new List<GameObject>());
        //判斷該類型對象池中有沒有物體
        if (dic[type].Count > 0)
        {
            int index = dic[type].Count - 1;
            temp = dic[type][index];
            dic[type].RemoveAt(index);
        }
        else
        {
            GameObject pre = GetPreByType(type);
            if (pre != null)
            {
                temp = Instantiate(pre, transform);
            }
        }
        temp.SetActive(true);
        temp.transform.position = pos;
        temp.transform.rotation = Quaternion.identity;
        return temp;
    }

    /// <summary>
    /// 回收
    /// </summary>
    /// <param name="type"></param>
    public void Add(ObjectType type, GameObject go)
    {
        //判斷該類型是否有對應的對象池以及對象池中不存在該物體
        if (dic.ContainsKey(type) && dic[type].Contains(go) == false)
        {
            //放入對象池
            dic[type].Add(go);
        }
        go.SetActive(false);
    }
}

• 有了這個簡單的對象池之后，我們再寫一個腳本MapController來生成場景中的一些墻體
• 通過兩個二維向量列表來生成普通墻體和超級墻體

我們需要給預制體標記不同的Tag用于區分它們各自的屬性

將以下預制體都添加上，只有墻體需要添加layer層，后面在怪物隨機移動時會用到，其他的只需要添加Tag即可

圖片.png

圖片.png

圖片.png

圖片.png

圖片.png

圖片.png

上代碼：

public class MapController : MonoBehaviour
{
    public GameObject doorPre;
    public int X, Y;
    private List<Vector2> nullPointsList = new List<Vector2>();
    private List<Vector2> superWallPointList = new List<Vector2>();
    private GameObject door;
    //表示從對象池中取出來的所有物體集合
    private Dictionary<ObjectType, List<GameObject>> poolObjectDic =
        new Dictionary<ObjectType, List<GameObject>>();

    /// <summary>
    /// 判斷當前位置是否是實體墻
    /// </summary>
    /// <param name="pos"></param>
    /// <returns></returns>
    public bool IsSuperWall(Vector2 pos)
    {
        if (superWallPointList.Contains(pos))
            return true;
        return false;
    }

    public Vector2 GetPlayerPos()
    {
        return new Vector2(-(X + 1), (Y - 1));
    }
    private void Recovery()
    {
        nullPointsList.Clear();
        superWallPointList.Clear();
        foreach (var item in poolObjectDic)
        {
            foreach (var obj in item.Value)
            {
                ObjectPool.Instance.Add(item.Key, obj);
            }
        }
        poolObjectDic.Clear();
    }
    public void InitMap(int x, int y, int wallCount, int enemyCount)
    {
        Recovery();
        X = x;
        Y = y;
        CreateSuperWall();
        FindNullPoints();
        CreateWall(wallCount);
        CreateDoor();
        CreateProps();
        CreateEnemy(enemyCount);
    }

    /// <summary>
    /// 生成實體墻
    /// </summary>
    private void CreateSuperWall()
    {
        for (int x = -X; x < X; x+=2)
        {
            for (int y = -Y; y < Y; y+=2)
            {
                SpawnSuperWall(new Vector2(x, y));
            }
        }

        for (int x = -(X + 2); x <= X; x++)
        {
            SpawnSuperWall(new Vector2(x, Y));
            SpawnSuperWall(new Vector2(x, -(Y + 2)));
        }

        for (int y = -(Y + 1); y <= Y-1; y++)
        {
            SpawnSuperWall(new Vector2(-(X + 2), y));
            SpawnSuperWall(new Vector2(X, y));
        }
    }

    private void SpawnSuperWall(Vector2 pos)
    {
        superWallPointList.Add(pos);
        GameObject superWall = ObjectPool.Instance.Get(ObjectType.SuperWall, pos);
        if (poolObjectDic.ContainsKey(ObjectType.SuperWall) == false)
            poolObjectDic.Add(ObjectType.SuperWall, new List<GameObject>());
       poolObjectDic[ObjectType.SuperWall].Add(superWall);
    }
    /// <summary>
    /// 查找地圖中所有的空點
    /// </summary>
    private void FindNullPoints()
    {  
        for (int x = -(X + 1); x <= (X -1); x++)
        {
            if (-(X + 1) % 2 == x % 2)
                for (int y = -(Y + 1); y <= (Y - 1); y++)
                {
                    nullPointsList.Add(new Vector2(x, y));
                }
            else
                for (int y = -(Y + 1); y <= (Y - 1); y += 2)
                {
                    nullPointsList.Add(new Vector2(x, y));
                }
        }

        nullPointsList.Remove(new Vector2(-(X + 1), (Y - 1)));  //將左上角第一個位置空出來，用來生成炸彈人（出生點）
        nullPointsList.Remove(new Vector2(-(X + 1), (Y - 2)));  //左上角第一個位置下面的位置，保證炸彈人能出來，不被自己炸死
        nullPointsList.Remove(new Vector2(-X, (Y - 1)));  //左上角第一個位置右邊的位置，保證炸彈人能出來，不被自己炸死
    }
    /// <summary>
    /// 創建可以銷毀的墻
    /// </summary>
    private void CreateWall(int wallCount)
    {
        if (wallCount >= nullPointsList.Count)
            wallCount = (int)(nullPointsList.Count * 0.7f);
        for (int i = 0; i < wallCount; i++)
        {
            int index = Random.Range(0, nullPointsList.Count);
            GameObject wall = ObjectPool.Instance.Get(ObjectType.Wall, nullPointsList[index]);
            nullPointsList.RemoveAt(index);

            if (poolObjectDic.ContainsKey(ObjectType.Wall) == false)
                poolObjectDic.Add(ObjectType.Wall, new List<GameObject>());
            poolObjectDic[ObjectType.Wall].Add(wall);
        }
    }
    private void CreateProps()
    {
        int count = Random.Range(0, 2 + (int)(nullPointsList.Count * 0.05f));
        for (int i = 0; i < count; i++)
        {
            int index = Random.Range(0, nullPointsList.Count);
            GameObject prop = ObjectPool.Instance.Get(ObjectType.Prop, nullPointsList[index]);
            nullPointsList.RemoveAt(index);

            if (poolObjectDic.ContainsKey(ObjectType.Prop) == false)
                poolObjectDic.Add(ObjectType.Prop, new List<GameObject>());
            poolObjectDic[ObjectType.Prop].Add(prop);
        }
    }
}

• 該腳本中，通過使用二維向量列表來生成墻體，并且生成之前判斷當前位置是否已經有物體存在

• 在一初始化地圖的時候，先將列表清空，再執行其他操作

• 然后我們新建一個GameController物體并掛載上GameController腳本

• 該腳本就是后面需要的游戲控制器，但是我們現在只讓他生成游戲地圖

上代碼：

    /// <summary>
    /// 關卡控制器
    /// </summary>
    private void LevelCtrl()
    {
        time = levelCount * 50 + 130;
        int x = 6 + 2 * (levelCount / 3);
        int y = 3 + 2 * (levelCount / 3);  //每3關增加2個
        if (x > 18)
            x = 18;
        if (y > 15)
            y = 15;

        enemyCount = (int)(levelCount * 1.5f) + 1;
        if (enemyCount > 40)
            enemyCount = 40;
        mapController.InitMap(x, y, x * y, enemyCount);
        if (player == null)
        {
            player = Instantiate(playerPre);
            playerCtrl = player.GetComponent<PlayerCtrl>();
            playerCtrl.Init(1, 3, 2);
        }
        playerCtrl.ResetPlayer();
        player.transform.position = mapController.GetPlayerPos();

        //回收場景中殘留的爆炸特效
        GameObject[] effects = GameObject.FindGameObjectsWithTag(Tags.BombEffect);
        foreach (var item in effects)
        {
            ObjectPool.Instance.Add(ObjectType.BombEffect, item);
        }
        
        Camera.main.GetComponent<CameraFollow>().Init(player.transform, x, y);
        levelCount++;
        UIController.Instance.PlayLevelFade(levelCount);
    }

    public bool IsSuperWall(Vector2 pos)
    {
        return mapController.IsSuperWall(pos);
    }

• 一個簡單地圖隨機生成后是這樣的~

圖片.png

第二步：墻體代碼

• 我們上一步中只是生成了地圖中的墻體，
• 在這些游戲對象身上都還要掛上一個腳本，才能讓他們各司其職
• 因為這些墻體他們的職責是有所不同的！

比如普通墻體身上的腳本Wall代碼：

public class Wall : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.CompareTag(Tags.BombEffect))
        {
            ObjectPool.Instance.Add(ObjectType.Wall, gameObject);
        }
    }
}

• 門Door身上的腳本，這個還有些特殊，因為他一開始是墻體，被我們用炸彈炸掉之后會變成通往下一關的門~
• 這也是炸彈人的經典玩法啦！

看一下Door腳本代碼！

    public Sprite doorSprite,defaultSp;
    private SpriteRenderer spriteRenderer;
    private void Awake()
    {
        spriteRenderer = GetComponent<SpriteRenderer>();
        defaultSp = spriteRenderer.sprite;
    }
    public void ResetDoor()
    {
        tag = "Wall";
        gameObject.layer = 8;
        spriteRenderer.sprite = defaultSp;
        GetComponent<Collider2D>().isTrigger = false;
    }
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.CompareTag(Tags.BombEffect))
        {
            tag = "Untagged";
            gameObject.layer = 0;
            spriteRenderer.sprite = doorSprite;
            GetComponent<Collider2D>().isTrigger = true;
        }
        if (collision.CompareTag(Tags.Player))
        {
            //判斷當前場景中的敵人是否都消滅了
            GameController.Instance.LoadNextLevel();
        }
    }

第三步：炸彈人制作

• 經過上面的地圖制作，我們就有了一個可以玩的場景了

• 那接下來當然是要添加主角炸彈人啦！

• 雖然我們的炸彈人只是一個"紙片人"，但是不影響我們丟炸彈炸敵人哈哈~

• 本游戲中的炸彈人是通過游戲控制器自動生成的，我們需要在角色身上掛載一個腳本，讓他控制炸彈人的移動和丟炸彈的方法

上腳本PlayerCtrl代碼

    /// <summary>
    /// 移動方法
    /// </summary>
    private void Move()
    {
        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");
        anim.SetFloat("Horizontal", h);
        anim.SetFloat("Vertical", v);
        rig.MovePosition(transform.position + new Vector3(h, v) * speed);
    }

    private void CreateBomb()
    {
        if (Input.GetKeyDown(KeyCode.Space) && bombCount > 0)
        {
            AudioController.Instance.PlayFire();
            bombCount--;
            GameObject bomb = ObjectPool.Instance.Get(ObjectType.Bomb,
                new Vector3(Mathf.RoundToInt(transform.position.x),
                Mathf.RoundToInt(transform.position.y)));
            bomb.GetComponent<Bomb>().Init(range, bombBoomTime, () => 
            {
                bombCount++;
                bombList.Remove(bomb);
            });
            bombList.Add(bomb);
        }
    }

然后炸彈人身上還有一個動畫控制器，用于炸彈人上下左右移動時分別播放不同的動畫

資源包中動畫片段都有，我們來設置上就好了，很簡單的動畫片段執行

圖片.png

圖片.png

動畫片段切換時的效果：

20210621194927254.gif

一個場景中簡單的移動效果：

20210621195243976.gif

還有角色死亡時播放動畫的方法代碼

    /// <summary>
    /// 播放結束動畫
    /// </summary>
    public void PlayDieAnim()
    {
        Time.timeScale = 0;
        anim.SetTrigger("Die");
    }
    /// <summary>
    /// 結束動畫播放完畢
    /// </summary>
    private void DieAnimFinish()
    {
        GameController.Instance.GameOver();
    }

死亡動畫效果：

20210621195958396.gif

第四步：炸彈處理

• 現在我們炸彈人有了，炸彈的預制體也有了，就是那一張精靈圖片~
• 然后現在我們需要掛載上腳本才能讓炸彈有一個向四周爆炸的效果！

炸彈身上有一個腳本Bomb，初始化方法Init在PlayerCtrl中炸彈人丟炸彈的時候被調用！
腳本中的DealyBoom方法用于處理被我們的炸彈人丟出來以后檢閱四周可爆炸的范圍~

然后炸彈爆炸后也有一個預制體，我們也需要在上面掛載一個腳本，讓他在炸彈爆炸后執行一個爆炸效果！

上腳本Bomb和BombEffect：

public class Bomb : MonoBehaviour
{
    private int range;
    private Action aniFinAction;
    public void Init(int range, float dealyTime, Action action)
    {
        this.range = range;
        StartCoroutine("DealyBoom", dealyTime);
        aniFinAction = action;
    }
    IEnumerator DealyBoom(float time)
    {
        yield return new WaitForSeconds(time);
        if(aniFinAction != null)
            aniFinAction();
        AudioController.Instance.PlayBoom();
        ObjectPool.Instance.Get(ObjectType.BombEffect, transform.position);
        Boom(Vector2.left);
        Boom(Vector2.right);
        Boom(Vector2.down);
        Boom(Vector2.up);
        ObjectPool.Instance.Add(ObjectType.Bomb, gameObject);
    }
    private void Boom(Vector2 dir)
    {
        for (int i = 1; i <= range; i++)
        {
            Vector2 pos = (Vector2)transform.position + dir * i;
            if (GameController.Instance.IsSuperWall(pos))
                break;
            ObjectPool.Instance.Get(ObjectType.BombEffect, pos);
        }
    }
}

public class BombEffect : MonoBehaviour
{
    private Animator anim;
    private void Awake()
    {
        anim = GetComponent<Animator>();
    }
    private void Update()
    {
        AnimatorStateInfo info = anim.GetCurrentAnimatorStateInfo(0);
        if (info.normalizedTime >= 1 && info.IsName("BombEffect"))
        {
            ObjectPool.Instance.Add(ObjectType.BombEffect, gameObject);
        }
    }
}

第五步：敵人制作

• 既然場景和主角都有了，那自然需要創建敵人啦
• 我們將敵人生成也放在控制墻體生成的腳本中，因為敵人也可以算是一個可以移動的墻體
• 只不過我們給他不一樣的素材，讓他比墻體變得特殊了而已
• 所以我們在MapController中新加入一個方法，用于生成敵人

生成敵人代碼

    private void CreateEnemy(int count)
    {
        for (int i = 0; i < count; i++)
        {
            int index = Random.Range(0, nullPointsList.Count);
            GameObject enemy = ObjectPool.Instance.Get(ObjectType.Enemy, nullPointsList[index]);
            enemy.GetComponent<EnemyAI>().Init();
            nullPointsList.RemoveAt(index);

            if (poolObjectDic.ContainsKey(ObjectType.Enemy) == false)
                poolObjectDic.Add(ObjectType.Enemy, new List<GameObject>());
            poolObjectDic[ObjectType.Enemy].Add(enemy);
        }
    }

• 然后敵人生成以后還要可以自由移動，然后尋找我們的炸彈人，只要碰到我們的炸彈人，炸彈人就會受到傷害

• 這里需要注意的細節還是挺多的，首先我們需要讓他上下左右隨機移動

• 移動是通過射線檢測來判斷的，這里我們給場景中的墻體的layer設置成8層

• 然后怪物在檢測的時候，只檢測第八層的物體來判斷自身是否可以向該方向移動

• 還要處理敵人在碰到炸彈人和他們的同類時，會改變自身的顏色，這樣會有一個簡單的視覺交互效果

上腳本EnemyAI腳本代碼

public class EnemyAI : MonoBehaviour
{
    private float speed = 0.04f;
    private Rigidbody2D rig;
    private SpriteRenderer spriteRenderer;
    private Color color;
    /// <summary>
    /// 方向：0上  1下  2左  3右
    /// </summary>
    private int dirId = 0;
    private Vector2 dirVector;
    private float rayDistance = 0.7f;
    private bool canMove = true;  //是否可以移動

    private void Awake()
    {
        spriteRenderer = GetComponent<SpriteRenderer>();
        color = spriteRenderer.color;
        rig = GetComponent<Rigidbody2D>();    
    }
    /// <summary>
    /// 初始化方法
    /// </summary>
    public void Init()
    {
        color.a = 1;  //當敵人穿過后離開時，恢復之前顏色
        spriteRenderer.color = color;
        canMove = true;
        InitDir(Random.Range(0, 4));
    }

    /// <summary>
    /// 初始化敵人方向
    /// </summary>
    /// <param name="dir"></param>
    private void InitDir(int dir)
    {
        dirId = dir;
        switch (dirId)
        {
            case 0:
                dirVector = Vector2.up;
                break;
            case 1:
                dirVector = Vector2.down;
                break;
            case 2:
                dirVector = Vector2.left;
                break;
            case 3:
                dirVector = Vector2.right;
                break;
            default:
                break;
        }
    }
    private void Update()
    {
        if (canMove)
            rig.MovePosition((Vector2)transform.position + dirVector * speed);
        else
            ChangeDir();
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        //消滅敵人
        if(collision.CompareTag(Tags.BombEffect) && gameObject.activeSelf)
        {
            GameController.Instance.enemyCount--;
            ObjectPool.Instance.Add(ObjectType.Enemy, gameObject);
        }
        if (collision.CompareTag(Tags.Enemy))
        {
            color.a = 0.3f;  //當敵人相互穿過時，改變其顏色為半透明
            spriteRenderer.color = color;
        }
        if (collision.CompareTag(Tags.SuperWall) || collision.CompareTag(Tags.Wall))
        {
            //復位
            transform.position = new Vector2(Mathf.RoundToInt(transform.position.x),
                Mathf.RoundToInt(transform.position.y));  //RoundToInt取整
            ChangeDir();
        }     
    }
    private void OnTriggerStay2D(Collider2D collision)
    {
        if (collision.CompareTag(Tags.Enemy))
        {
            color.a = 0.3f;  //當敵人在一塊時，改變其顏色為半透明
            spriteRenderer.color = color;
        }
    }
    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.CompareTag(Tags.Enemy))
        {
            color.a = 1;  //當敵人穿過后離開時，恢復之前顏色
            spriteRenderer.color = color;
        }
    }

    private void ChangeDir()
    {
        List<int> dirList = new List<int>();
        if (Physics2D.Raycast(transform.position, Vector2.up, rayDistance, 1 << 8) == false)
        //1左移8，表示只檢測第8層（添加 Layer）。  若是 0 << 8 則表示忽略第8層
        {
            dirList.Add(0);  //如果上方沒有檢測到物體就向上方移動
        }
        if (Physics2D.Raycast(transform.position, Vector2.down, rayDistance, 1 << 8) == false)
        {
            dirList.Add(1);
        }
        if (Physics2D.Raycast(transform.position, Vector2.left, rayDistance, 1 << 8) == false)
        {
            dirList.Add(2);
        }
        if (Physics2D.Raycast(transform.position, Vector2.right, rayDistance, 1 << 8) == false)
        {
            dirList.Add(3);
        }

        if (dirList.Count > 0)
        {
            canMove = true;
            int index = Random.Range(0, dirList.Count);
            InitDir(dirList[index]);
        }
        else
            canMove = false;
    }

    private void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawLine(transform.position, transform.position + new Vector3(0, rayDistance, 0));
        Gizmos.color = Color.blue;
        Gizmos.DrawLine(transform.position, transform.position + new Vector3(0, -rayDistance, 0));
        Gizmos.DrawLine(transform.position, transform.position + new Vector3(-rayDistance, 0, 0));
        Gizmos.DrawLine(transform.position, transform.position + new Vector3(rayDistance, 0, 0));
    }

怪物自動移動效果：

20210621200742136.gif

第六步：游戲控制器

終于到了游戲控制器這一步啦~

細心地小伙伴可能發現了，從開頭到現在大部分都是代碼

因為這個小游戲在引擎操作的步驟真的很少，大多數都在腳本上進行的邏輯編寫，所以本篇文章可能有些枯燥~

• 如果說上面的步驟已經將游戲大概玩法寫完了，那這一步則是最為重要的游戲控制器的編寫

• 這個游戲中的游戲控制器，用于控制一個游戲的進行

• 如果說沒有游戲控制器，那就相當于一個沒有游戲規則的游戲Demo

• 有了游戲控制器才算是一個制定游戲規則的人，才能讓游戲有條不紊的進行下去！

那就來搞一下我們這個游戲控制器吧！

我們通過游戲控制器給這個炸彈人小游戲設置關卡

還有一個關卡計數器，判斷下一關的進行，和更新地圖和怪物！

最后還要有一個游戲結束界面，在炸彈人三條命都用完的時候觸發結束界面~

好了，大體思路 就是這樣了

上GameController腳本代碼看一下：

   /// <summary>
    /// 關卡計時器
    /// </summary>
    private void LevelTimer()
    {
        //時間用完了，游戲結束
        if (time <= 0)
        {
            if (playerCtrl.HP > 0)
            {
                playerCtrl.HP--;  //用生命換時間
                time = 200;
                return;
            }
            playerCtrl.PlayDieAnim();
            return;
        }
        timer += Time.deltaTime;
        if (timer >= 1.0f)
        {
            time--;
            timer = 0;
        }
    }
    /// <summary>
    /// 游戲結束
    /// </summary>
    public void GameOver()
    {                     
        UIController.Instance.ShowGameOverPanel();  //顯示游戲結束界面
    }
    private void Update()
    {
        LevelTimer();
       // UIController.Instance.Refresh(playerCtrl.HP, levelCount, time, enemyCount);
    }
    /// <summary>
    /// 加載下一關
    /// </summary>
    public void LoadNextLevel()
    {
        if (enemyCount <= 0)
            LevelCtrl();
    }
    /// <summary>
    /// 關卡控制器
    /// </summary>
    private void LevelCtrl()
    {
        time = levelCount * 50 + 130;
        int x = 6 + 2 * (levelCount / 3);
        int y = 3 + 2 * (levelCount / 3);  //每3關增加2個
        if (x > 18)
            x = 18;
        if (y > 15)
            y = 15;

        enemyCount = (int)(levelCount * 1.5f) + 1;
        if (enemyCount > 40)
            enemyCount = 40;
        mapController.InitMap(x, y, x * y, enemyCount);
        if (player == null)
        {
            player = Instantiate(playerPre);
            playerCtrl = player.GetComponent<PlayerCtrl>();
            playerCtrl.Init(1, 3, 2);
        }
        playerCtrl.ResetPlayer();
        player.transform.position = mapController.GetPlayerPos();

        //回收場景中殘留的爆炸特效
        GameObject[] effects = GameObject.FindGameObjectsWithTag(Tags.BombEffect);
        foreach (var item in effects)
        {
            ObjectPool.Instance.Add(ObjectType.BombEffect, item);
        }
        
        Camera.main.GetComponent<CameraFollow>().Init(player.transform, x, y);
        levelCount++;
        UIController.Instance.PlayLevelFade(levelCount);
    }

    public bool IsSuperWall(Vector2 pos)
    {
        return mapController.IsSuperWall(pos);
    }

第七步：UI控制器

• 然后關卡內有時間限制，如果本關時間到了，那也算輸掉了

• 還有就是給炸彈人三條命，被怪物碰到就會丟一條命，然后有一個無敵時間，恢復總時間，就是拿命換時間~

• 生命和時間的話我們放在UI控制器里面，因為這倆都是UI方面的

• 顯示生命和時間的UI控制腳本UIController

• 在在腳本中不止顯示生命和時間，還要顯示當前的關卡和剩余的怪物數量

• 所有與UI相關的額控制，我們都放到這個腳本中用于控制！

例如第一關的話就是這樣的

圖片.png

上代碼看一下：

 private void Init()
    {
        gameOverPanel.transform.Find("btn_Again").GetComponent<Button>().onClick.AddListener(() =>
        {
            Time.timeScale = 1;
            //重新加載當前正在運行的場景
            SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
        });
        gameOverPanel.transform.Find("btn_Main").GetComponent<Button>().onClick.AddListener(() =>
        {
            Time.timeScale = 1;
            SceneManager.LoadScene("Start");
        });
    }
    public void Refresh(int hp, int level, int time, int enemy)
    {
        txt_HP.text = "HP：" + hp.ToString();
        txt_Level.text = "Level：" + level.ToString();
        txt_Time.text = "Time：" + time.ToString();
        txt_Enemy.text = "Enemy：" + enemy.ToString();
    }
    public void ShowGameOverPanel()
    {
        gameOverPanel.SetActive(true);
    }
    /// <summary>
    /// 播放關卡提示動畫
    /// </summary>
    /// <param name="levelIndex"></param>
    public void PlayLevelFade(int levelIndex)
    {
        Time.timeScale = 0;
        levelFadeAnim.transform.Find("txt_Level").GetComponent<Text>().text = "Level " + levelIndex.ToString();
        levelFadeAnim.Play("LevelFade", 0, 0);
        startDelay = true;
    }
    private bool startDelay = false;
    private float timer = 0;
    private void Update()
    {       
        if (startDelay)
        {
            timer += Time.unscaledDeltaTime;
            if (timer > 0.7f)
            {
                startDelay = false;
                Time.timeScale = 1;
                timer = 0;
            }
        }
    }

??資源下載

• 工程的資源包放在這里啦，包含完整的小游戲工程源碼，私信我就好~

• [炸彈人小游戲源碼加直接可以玩的炸彈人exe文件下載]

• 該資源包含炸彈人Unity的源碼工程和我已經打包出來的exe文件，可以直接點擊exe就可以玩啦

<font color=#48d1cc size=4 >點擊下圖所示就可以直接試玩游戲了！快來下載然后分享給小伙伴們一起制作或者試玩吧~</font>

()

??總結

本篇文章給大家分享了一個經典的炸彈人小游戲，不知道大家學會了沒呢~

大家可能也發現了，在本篇文章中，很多地方都是代碼的使用

在Unity引擎操作的地方并不是很多，難點其實也都在腳本代碼中

所以也正是想借著一篇文章來告訴大家一些事：

• 有很多人眼中開發游戲的，可能就覺得很輕松，甚至會有些人覺得就是不務正業，為了玩游戲才去美其名曰—開發游戲??！
• 但是游戲中的程序其實大多數時間都是很枯燥、很令人頭禿的??~
• 一些復雜的操作都是程序員使用代碼開發出來的，那寫代碼就很簡單嗎??？
• 答案很明顯，如果寫代碼很簡單的話，就不會有那么多頭禿的程序員了??
• 所以啊，不管在哪一行，都沒有那么輕松就可以賺到錢的，還需要更多的努力呀??~

好啦，文章是用來學習的，不是說一堆廢話的（其實就是單純為了給文章增加點字數的??...）
哈哈，一不小心就真相了??
覺得博主寫的還湊合的，一波三連加評論吧??！ 下次再見啦??！

再見1.gif