Unity如何實現炸彈人游戲

這篇文章給大家分享的是有關Unity如何實現炸彈人游戲的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

前言

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

制作思路

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

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

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

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

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

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

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

• 然后還要有血量等等

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

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

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

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

開始制作

• 導入素材資源包

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

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

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

第一步：游戲場景制作

• 我們是一個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即可

上代碼：

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);
    }

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

第二步：墻體代碼

• 我們上一步中只是生成了地圖中的墻體，

• 在這些游戲對象身上都還要掛上一個腳本，才能讓他們各司其職

• 因為這些墻體他們的職責是有所不同的！

比如普通墻體身上的腳本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);
        }
    }

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

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

動畫片段切換時的效果：

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

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

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

死亡動畫效果：

第四步：炸彈處理

• 現在我們炸彈人有了，炸彈的預制體也有了，就是那一張精靈圖片~

• 然后現在我們需要掛載上腳本才能讓炸彈有一個向四周爆炸的效果！

炸彈身上有一個腳本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));
    }

怪物自動移動效果：

第六步：游戲控制器

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

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

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

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

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

• 如果說沒有游戲控制器，那就相當于一個沒有游戲規則的游戲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相關的額控制，我們都放到這個腳本中用于控制！

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

上代碼看一下：

 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;
            }
        }
    }

感謝各位的閱讀！關于“Unity如何實現炸彈人游戲”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！