Unity游戲開發(fā)之炸彈人游戲的實(shí)現(xiàn)

更新時(shí)間：2022年03月18日 10:32:21 作者：呆呆敲代碼的小Y

大家小時(shí)候肯定玩過這款游戲，炸彈人也算是經(jīng)典中的經(jīng)典啦。本文將利用Unity模擬實(shí)現(xiàn)這一經(jīng)典游戲，感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下

前言

大家小時(shí)候肯定玩過這款游戲，炸彈人也算是經(jīng)典中的經(jīng)典啦~

希望看到這篇小游戲，可以讓你重拾童年跟小伙伴一起對(duì)著大屁股電視機(jī)玩游戲的美好時(shí)光！

時(shí)間在慢慢的流逝，那些陪你一起度過童年的小伙伴有多久沒聯(lián)系了呢~

看完這篇炸彈人，有時(shí)間的話就找自己童年的小伙伴們聊會(huì)天吧，一起找回童年的回憶和夢(mèng)想！

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

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

制作思路

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

首先要有一個(gè)游戲場(chǎng)景，這個(gè)場(chǎng)景就是我們?cè)谟螒蜻\(yùn)行的時(shí)候，我們可以看到的地方
這個(gè)場(chǎng)景中會(huì)有許多墻體，其中四周會(huì)有一個(gè)游戲邊緣墻體，這些墻體是無法被我們的炸彈毀掉的，稱他為超級(jí)墻體！
場(chǎng)景里面也會(huì)有一些墻體，可以被摧毀，我們成為普通墻體~
有些是固定的，有些是可被摧毀的，這就是一個(gè)經(jīng)典的炸彈人玩法了！
其次，我們要有一個(gè)主角，就是我們的炸彈人！
我們的主角可以上下左右移動(dòng)，然后還可以"下蛋"，就是放炸彈，炸敵人
然后還要有血量等等
當(dāng)然少不了敵人了，我們給場(chǎng)景中加入一個(gè)可以隨機(jī)左右移動(dòng)的敵人，碰到我們之后就會(huì)讓我們掉血
這也是一個(gè)最經(jīng)典而且基礎(chǔ)的玩法啦~

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

那我們現(xiàn)在就開始動(dòng)手操作吧！

開始制作

導(dǎo)入素材資源包
導(dǎo)入后，工程資源是這樣的

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

還有幾個(gè)簡(jiǎn)單的聲音特效和動(dòng)畫特效，為我們的游戲制作提供后勤支援！

第一步：游戲場(chǎng)景制作

我們是一個(gè)2D游戲，在這里的游戲場(chǎng)景中，地圖是精靈圖片做的
我們這里寫個(gè)腳本，讓他在游戲運(yùn)行時(shí)，直接生成相應(yīng)的地圖
這里是用了一個(gè)對(duì)象池腳本ObjectPool，用來拿到工程中所有的資源，然后需要使用的時(shí)候從對(duì)象池生成到場(chǎng)景中
這里就不多介紹對(duì)象池了，方法有很多種
這里提供一種作為參考，可直接掛到場(chǎng)景中使用即可

上代碼：

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>
    /// 通過物體類型獲取該預(yù)制體
    /// </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>
    /// 物體類型和對(duì)應(yīng)的對(duì)象池關(guān)系字典
    /// </summary>
    private Dictionary<ObjectType, List<GameObject>> dic =
        new Dictionary<ObjectType, List<GameObject>>();

    private void Awake()
    {
        Instance = this;
    }
    /// <summary>
    /// 通過物體類型從相對(duì)應(yīng)的對(duì)象池中取東西
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public GameObject Get(ObjectType type, Vector2 pos)
    {
        GameObject temp = null;
        //判斷字典中有沒有與該類型匹配的對(duì)象池，沒有則創(chuàng)建
        if (dic.ContainsKey(type) == false)
            dic.Add(type, new List<GameObject>());
        //判斷該類型對(duì)象池中有沒有物體
        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)
    {
        //判斷該類型是否有對(duì)應(yīng)的對(duì)象池以及對(duì)象池中不存在該物體
        if (dic.ContainsKey(type) && dic[type].Contains(go) == false)
        {
            //放入對(duì)象池
            dic[type].Add(go);
        }
        go.SetActive(false);
    }
}

有了這個(gè)簡(jiǎn)單的對(duì)象池之后，我們?cè)賹懸粋€(gè)腳本MapController來生成場(chǎng)景中的一些墻體
通過兩個(gè)二維向量列表來生成普通墻體和超級(jí)墻體

我們需要給預(yù)制體標(biāo)記不同的Tag用于區(qū)分它們各自的屬性

將以下預(yù)制體都添加上，只有墻體需要添加layer層，后面在怪物隨機(jī)移動(dòng)時(shí)會(huì)用到，其他的只需要添加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;
    //表示從對(duì)象池中取出來的所有物體集合
    private Dictionary<ObjectType, List<GameObject>> poolObjectDic =
        new Dictionary<ObjectType, List<GameObject>>();

    /// <summary>
    /// 判斷當(dāng)前位置是否是實(shí)體墻
    /// </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>
    /// 生成實(shí)體墻
    /// </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>
    /// 查找地圖中所有的空點(diǎn)
    /// </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)));  //將左上角第一個(gè)位置空出來，用來生成炸彈人（出生點(diǎn)）
        nullPointsList.Remove(new Vector2(-(X + 1), (Y - 2)));  //左上角第一個(gè)位置下面的位置，保證炸彈人能出來，不被自己炸死
        nullPointsList.Remove(new Vector2(-X, (Y - 1)));  //左上角第一個(gè)位置右邊的位置，保證炸彈人能出來，不被自己炸死
    }
    /// <summary>
    /// 創(chuàng)建可以銷毀的墻
    /// </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);
        }
    }
}

該腳本中，通過使用二維向量列表來生成墻體，并且生成之前判斷當(dāng)前位置是否已經(jīng)有物體存在
在一初始化地圖的時(shí)候，先將列表清空，再執(zhí)行其他操作
然后我們新建一個(gè)GameController物體并掛載上GameController腳本
該腳本就是后面需要的游戲控制器，但是我們現(xiàn)在只讓他生成游戲地圖

上代碼：

    /// <summary>
    /// 關(guān)卡控制器
    /// </summary>
    private void LevelCtrl()
    {
        time = levelCount * 50 + 130;
        int x = 6 + 2 * (levelCount / 3);
        int y = 3 + 2 * (levelCount / 3);  //每3關(guān)增加2個(gè)
        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();

        //回收?qǐng)鼍爸袣埩舻谋ㄌ匦?
        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);
    }

一個(gè)簡(jiǎn)單地圖隨機(jī)生成后是這樣的~

第二步：墻體代碼

我們上一步中只是生成了地圖中的墻體，
在這些游戲?qū)ο笊砩隙歼€要掛上一個(gè)腳本，才能讓他們各司其職
因?yàn)檫@些墻體他們的職責(zé)是有所不同的！

比如普通墻體身上的腳本W(wǎng)all代碼：

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

門Door身上的腳本，這個(gè)還有些特殊，因?yàn)樗婚_始是墻體，被我們用炸彈炸掉之后會(huì)變成通往下一關(guān)的門~
這也是炸彈人的經(jīng)典玩法啦！

看一下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))
        {
            //判斷當(dāng)前場(chǎng)景中的敵人是否都消滅了
            GameController.Instance.LoadNextLevel();
        }
    }

第三步：炸彈人制作

經(jīng)過上面的地圖制作，我們就有了一個(gè)可以玩的場(chǎng)景了
那接下來當(dāng)然是要添加主角炸彈人啦！
雖然我們的炸彈人只是一個(gè)"紙片人"，但是不影響我們丟炸彈炸敵人哈哈~
本游戲中的炸彈人是通過游戲控制器自動(dòng)生成的，我們需要在角色身上掛載一個(gè)腳本，讓他控制炸彈人的移動(dòng)和丟炸彈的方法

上腳本PlayerCtrl代碼

    /// <summary>
    /// 移動(dòng)方法
    /// </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);
        }
    }

然后炸彈人身上還有一個(gè)動(dòng)畫控制器，用于炸彈人上下左右移動(dòng)時(shí)分別播放不同的動(dòng)畫

資源包中動(dòng)畫片段都有，我們來設(shè)置上就好了，很簡(jiǎn)單的動(dòng)畫片段執(zhí)行

動(dòng)畫片段切換時(shí)的效果：

一個(gè)場(chǎng)景中簡(jiǎn)單的移動(dòng)效果：

還有角色死亡時(shí)播放動(dòng)畫的方法代碼

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

死亡動(dòng)畫效果：

第四步：炸彈處理

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

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

然后炸彈爆炸后也有一個(gè)預(yù)制體，我們也需要在上面掛載一個(gè)腳本，讓他在炸彈爆炸后執(zhí)行一個(gè)爆炸效果！

上腳本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);
        }
    }
}

第五步：敵人制作

既然場(chǎng)景和主角都有了，那自然需要?jiǎng)?chuàng)建敵人啦
我們將敵人生成也放在控制墻體生成的腳本中，因?yàn)閿橙艘部梢运闶且粋€(gè)可以移動(dòng)的墻體
只不過我們給他不一樣的素材，讓他比墻體變得特殊了而已
所以我們?cè)贛apController中新加入一個(gè)方法，用于生成敵人

生成敵人代碼

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

然后敵人生成以后還要可以自由移動(dòng)，然后尋找我們的炸彈人，只要碰到我們的炸彈人，炸彈人就會(huì)受到傷害
這里需要注意的細(xì)節(jié)還是挺多的，首先我們需要讓他上下左右隨機(jī)移動(dòng)
移動(dòng)是通過射線檢測(cè)來判斷的，這里我們給場(chǎng)景中的墻體的layer設(shè)置成8層
然后怪物在檢測(cè)的時(shí)候，只檢測(cè)第八層的物體來判斷自身是否可以向該方向移動(dòng)
還要處理敵人在碰到炸彈人和他們的同類時(shí)，會(huì)改變自身的顏色，這樣會(huì)有一個(gè)簡(jiǎn)單的視覺交互效果

上腳本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;  //是否可以移動(dòng)

    private void Awake()
    {
        spriteRenderer = GetComponent<SpriteRenderer>();
        color = spriteRenderer.color;
        rig = GetComponent<Rigidbody2D>();    
    }
    /// <summary>
    /// 初始化方法
    /// </summary>
    public void Init()
    {
        color.a = 1;  //當(dāng)敵人穿過后離開時(shí)，恢復(fù)之前顏色
        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;  //當(dāng)敵人相互穿過時(shí)，改變其顏色為半透明
            spriteRenderer.color = color;
        }
        if (collision.CompareTag(Tags.SuperWall) || collision.CompareTag(Tags.Wall))
        {
            //復(fù)位
            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;  //當(dāng)敵人在一塊時(shí)，改變其顏色為半透明
            spriteRenderer.color = color;
        }
    }
    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.CompareTag(Tags.Enemy))
        {
            color.a = 1;  //當(dāng)敵人穿過后離開時(shí)，恢復(fù)之前顏色
            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，表示只檢測(cè)第8層（添加 Layer）。  若是 0 << 8 則表示忽略第8層
        {
            dirList.Add(0);  //如果上方?jīng)]有檢測(cè)到物體就向上方移動(dòng)
        }
        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));
    }

怪物自動(dòng)移動(dòng)效果：

第六步：游戲控制器

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

細(xì)心地小伙伴可能發(fā)現(xiàn)了，從開頭到現(xiàn)在大部分都是代碼

因?yàn)檫@個(gè)小游戲在引擎操作的步驟真的很少，大多數(shù)都在腳本上進(jìn)行的邏輯編寫，所以本篇文章可能有些枯燥~

如果說上面的步驟已經(jīng)將游戲大概玩法寫完了，那這一步則是最為重要的游戲控制器的編寫
這個(gè)游戲中的游戲控制器，用于控制一個(gè)游戲的進(jìn)行
如果說沒有游戲控制器，那就相當(dāng)于一個(gè)沒有游戲規(guī)則的游戲Demo
有了游戲控制器才算是一個(gè)制定游戲規(guī)則的人，才能讓游戲有條不紊的進(jìn)行下去！

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

我們通過游戲控制器給這個(gè)炸彈人小游戲設(shè)置關(guān)卡

還有一個(gè)關(guān)卡計(jì)數(shù)器，判斷下一關(guān)的進(jìn)行，和更新地圖和怪物！

最后還要有一個(gè)游戲結(jié)束界面，在炸彈人三條命都用完的時(shí)候觸發(fā)結(jié)束界面~

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

上GameController腳本代碼看一下：

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

        //回收?qǐng)鼍爸袣埩舻谋ㄌ匦?
        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控制器

然后關(guān)卡內(nèi)有時(shí)間限制，如果本關(guān)時(shí)間到了，那也算輸?shù)袅?/li>
還有就是給炸彈人三條命，被怪物碰到就會(huì)丟一條命，然后有一個(gè)無敵時(shí)間，恢復(fù)總時(shí)間，就是拿命換時(shí)間~
生命和時(shí)間的話我們放在UI控制器里面，因?yàn)檫@倆都是UI方面的
顯示生命和時(shí)間的UI控制腳本UIController
在在腳本中不止顯示生命和時(shí)間，還要顯示當(dāng)前的關(guān)卡和剩余的怪物數(shù)量
所有與UI相關(guān)的額控制，我們都放到這個(gè)腳本中用于控制！

例如第一關(guān)的話就是這樣的

上代碼看一下：

 private void Init()
    {
        gameOverPanel.transform.Find("btn_Again").GetComponent<Button>().onClick.AddListener(() =>
        {
            Time.timeScale = 1;
            //重新加載當(dāng)前正在運(yùn)行的場(chǎng)景
            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>
    /// 播放關(guān)卡提示動(dòng)畫
    /// </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游戲開發(fā)之炸彈人游戲的實(shí)現(xiàn)的詳細(xì)內(nèi)容，更多關(guān)于Unity炸彈人游戲的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: