重回童年的经典系列☀️|【炸弹人小游戏】制作过程+解析 | 收藏起来跟曾经的小伙伴一起梦回童年！

最新推荐文章于 2023-09-04 11:33:54 发布
最新推荐文章于 2023-09-04 11:33:54 发布
阅读量10w+ 收藏 461
点赞数 407
分类专栏： ⭐️游戏专栏⭐️ 文章标签： Unity 游戏 游戏开发 童年回忆 新星计划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangay1998/article/details/118101452
版权
⭐️游戏专栏⭐️ 专栏收录该内容
14 篇文章 591 订阅 ¥39.90 ¥99.00
订阅专栏
本文通过Unity详细介绍了如何制作炸弹人小游戏，包括游戏场景制作、墙体代码、主角与敌人制作、炸弹处理等步骤，带领读者重拾童年回忆。文章提供了完整的工程源码供读者下载和试玩。
摘要由CSDN通过智能技术生成
  • 📢博客主页：https://blog.csdn.net/zhangay1998
  • 📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
  • 📢本文由 God Y.原创，首发于 CSDN🙉
  • 📢未来很长，值得我们全力奔赴更美好的生活✨

🎉炸弹人

📢前言
  • 本篇博客是写了一篇很简单的炸弹人游戏，让你重拾童年的回忆~
  • 最近在参加新星计划，这是最后一周了，在前面几周的表现还不错，实在是肝爆了…
  • 时间实在是不够用啦，挤牙膏搞出来这个炸弹人的小游戏，希望大家三连支持一下~
  • 工程源码在文章最后，感兴趣的可以下载试玩，也可以自己尝试制作一下玩哦~
  • 大家小时候肯定玩过这款游戏，炸弹人也算是经典中的经典啦🤪~
  • 希望看到这篇小游戏，可以让你重拾童年跟小伙伴一起对着大屁股电视机玩游戏的美好时光😁！
  • 时间在慢慢的流逝，那些陪你一起度过童年的小伙伴有多久没联系了呢😃~
  • 看完这篇炸弹人，有时间的话就找自己童年的小伙伴们聊会天吧，一起找回童年的回忆和梦想😊！

在这里插入图片描述

回归主题，炸弹人小游戏制作开始！

🎁正文

来看一下炸弹人小游戏的效果吧！

在这里插入图片描述

💫制作思路

老规矩，做之前我们先来整一下做这个小游戏的思路
让我们动一下脑袋瓜想一下一个炸弹人小游戏里面都有什么东西呢

  • 首先要有一个游戏场景，这个场景就是我们在游戏运行的时候，我们可以看到的地方

  • 这个场景中会有许多墙体，其中四周会有一个游戏边缘墙体，这些墙体是无法被我们的炸弹毁掉的，称他为超级墙体！

  • 场景里面也会有一些墙体，可以被摧毁，我们成为普通墙体~

  • 有些是固定的，有些是可被摧毁的，这就是一个经典的炸弹人玩法了！

  • 其次，我们要有一个主角，就是我们的炸弹人！

  • 我们的主角可以上下左右移动，然后还可以"下蛋"，就是放炸弹，炸敌人

  • 然后还要有血量等等

  • 当然少不了敌人了，我们给场景中加入一个可以随机左右移动的敌人，碰到我们之后就会让我们掉血

  • 这也是一个最经典而且基础的玩法啦~

乍一想好像也就这么点东西，也不是很难的样子

那我们现在就开始动手操作吧！

🌟开始制作

  • 导入素材资源包
  • 导入后，工程资源是这样的
    在这里插入图片描述

其中有一些精灵图片素材，为我们做主角、敌人和墙体时候使用

还有几个简单的声音特效和动画特效，为我们的游戏制作提供后勤支援！

第一步：游戏场景制作

  • 我们是一个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引擎操作的地方并不是很多，难点其实也都在脚本代码中

所以也正是想借着一篇文章来告诉大家一些事：

  • 有很多人眼中开发游戏的，可能就觉得很轻松，甚至会有些人觉得就是不务正业，为了玩游戏才去美其名曰—开发游戏🙃！
  • 但是游戏中的程序其实大多数时间都是很枯燥、很令人头秃的💀~
  • 一些复杂的操作都是程序员使用代码开发出来的，那写代码就很简单吗🙄？
  • 答案很明显，如果写代码很简单的话，就不会有那么多头秃的程序员了😂
  • 所以啊，不管在哪一行，都没有那么轻松就可以赚到钱的，还需要更多的努力呀🥰~

好啦，文章是用来学习的，不是说一堆废话的（其实就是单纯为了给文章增加点字数的😳…）
哈哈，一不小心就真相了😁
觉得博主写的还凑合的，一波三连加评论吧😍！ 下次再见啦👋！

在这里插入图片描述

呆呆敲代码的小Y
关注
专栏目录
订阅专栏
Unity实战篇 | 自己制作一个《大转盘抽奖》 小程序，顺便带你看看抽奖的水可以有多深
努力前行，总会成为自己心中的那道光
12-24 5万+
今天给大家带来一个转盘抽奖的小项目。 在游戏开发日常中，抽奖的需求可算是超级常见了。 那今天就来做这个小项目，顺便了解一下抽奖都有什么内幕吧！ #转盘抽奖小程序制作 首先来说一下转盘抽奖小程序的组成 转盘抽奖主要是由两部分组成，一个是转盘，另一个是指针。
泡泡堂(炸弹人)小游戏CC++完整源码，附游戏背景音乐及图片。.zip
10-24
泡泡堂(炸弹人)小游戏CC++完整源码，附游戏背景音乐及图片。.zip 泡泡堂(炸弹人)小游戏CC++完整源码，附游戏背景音乐及图片。.zip
【用unity实现100个游戏之8】用Unity制作一个炸弹人游戏（附项目源码）
最新发布
向宇
09-04 2010
我们将在这个视频中，学习如何在Unity中制作《炸弹人心》，《炸弹人》是—个游戏系列，最初于1983年7月在日本发行，《炸弹人》的游戏玩法包括策略性地放炸弹，在一定时间后以多个方向爆炸，以摧毁障碍物和杀死敌人。本文重点介绍了实现瓦片地图精灵动画的方法，你可以用许多不同的方式自定义游戏，想出独特的游戏模式并建立自己的关卡。先来看看实现的最终效果。
Unity2D小游戏——类似QQ堂的小 demo(炸弹人)
凉夏微微
11-14 6204
一 ： 语言 ：C# 点击这里下载项目工程 二 ： 涉及到的功能： 1.主角，上下左右移动 2.主角，放置炸弹 3.炸弹可以销毁某些砖块，敌人 4.通过射线检测，实现敌人随机运动 三：效果图（游戏中用到的图片来源于网络，侵删） 四 ：代码 （1），主角移动脚本 using System.Collections; using System.Coll...
【Unity3D开发小游戏】《炸弹人游戏》Unity开发教程
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
09-11 8324
一、前言 我们的炸弹人游戏灵感源于1983年的原始炸弹人，听起来像一个很古老的游戏，但是确实是一个很有趣的游戏。 我们将使用几个有趣的Unity功能，如刚体，Colliders 和Sprite Editor。我们还将学习如何正确地使用Unity的强大的Mecanim动画系统。 二、版本 Unity 5.0.1f1 三、让我们开始吧 背景色 我们在Hierarchy面板中选择主照相机，在Inspec...
如何用 Unity 编写像炸弹人一样的游戏
kmyhy的专栏
04-11 7822
原文：How To Make A Game Like Bomberman With Unity 作者：Brian Broom 译者：kmyhy 更新说明：本教程由 Brian Broom 更新至 Unity 2017.1。原教程作者是 Eric Van de Kerckhove。 炸弹游戏很好玩。和朋友一起玩炸弹游戏就更好玩了。将你的朋友炸死了吗？赢家出现了！ 但...
做游戏，学编程（C语言） 12 炸弹人
weixin_49630241的博客
01-23 2131
这个案例，介绍15级同学大一时写的炸弹人游戏，分步骤代码可从百度云盘下载：http://pan.baidu.com/s/1cnawGY主要效果可点击下图观看：整个游戏的开发主要包括8个步骤：1.做出画布,并输出石头2.玩家的移动3.用二维数组输出砖块和添加开始界面4.玩家放炸弹5.做出一个可以自由移动的敌人6.多个可以自由移动的敌人7.玩家的死亡并添加音乐8.敌人的死亡以下为更详细的分步骤实现思路...
JS+HTML实现炸弹人小游戏demo
05-05
【标题】"JS+HTML实现炸弹人小游戏demo"揭示了一个基于JavaScript和HTML技术构建的简易版经典游戏——炸弹人。这款游戏在20世纪80年代非常流行，玩家控制的角色会在迷宫般的地图上放置炸弹来炸毁障碍物和敌人，同时...
Python炸弹人小游戏源代码
03-31
【Python炸弹人小游戏源代码】是一款基于Python编程语言和Pygame库开发的趣味游戏，它融合了动作、策略和解谜元素。Pygame是Python的一个模块，专门用于创建2D游戏，提供了丰富的图形、音频和事件处理功能。下面将...
Python小游戏源码-炸弹人小游戏游戏源码
02-27
【Python小游戏源码-炸弹人小游戏游戏源码】 在编程世界中，开发游戏是一种极好的学习和实践技术的方式。Python语言以其简洁明了的语法和丰富的库资源，成为了初学者和专业开发者创建游戏的热门选择。"炸弹人"是一...
html5炸弹人游戏源码
02-02
html5炸弹人游戏源码、有自己炸弹和敌人还有地图墙壁等图片资源、有a*算法
unity3D游戏引擎制作，简易版炸弹人
01-08
unity3D游戏引擎制作，简易版炸弹人，包含发布的游戏和源码。
unity炸弹人游戏开发
03-15
unity写的2d炸弹人游戏，经典的游戏，有兴趣的可以下载进一步开发。非常不错。
炸弹人unity
05-28
炸弹人unity
Unity 2D小游戏炸弹人
07-04
这不是完整的资源，没有写完，大家可以看看，希望有点帮组。
Unity2D小游戏——炸弹人（类似qq堂的小demo）
06-05
2.主角，放置炸弹 3.炸弹可以销毁某些砖块，敌人 4.通过射线检测，实现敌人随机运动 可以先去我的CSDN博客看该项目介绍，再决定是否下载。 https://blog.csdn.net/qq_39225721/article/details/80518796
unity3d自学日记 第15天 - 3d炸弹人demo效果实现
vnfgh4的博客
05-06 606
实现通过键盘控制人物移动以及动画状态机的切换，实现释放炸弹 炸死敌人以及爆炸效果，实现敌人简单ai,发现玩家后自动朝玩家攻击。
【Pygame小游戏】这款经典的炸弹人超能游戏上线，你爱了嘛？（附源码）
TZ45678的博客
03-31 4056
前言 🚀 作者 ：“程序员梨子” 🚀 **文章简介 **：本篇文章主要是写了pygame实现仿泡泡堂的小游戏！ 🚀 **文章源码免费获取 ： 为了感谢每一个关注我的小可爱💓每篇文章的项目源码都是无 偿分享滴💓👇👇👇👇 点这里蓝色这行字体自取，需要什么源码记得说标题名字哈！私信我也可！ 🚀 欢迎小伙伴们 点赞👍、收藏⭐、留言💬 正文 在现在这个浮躁的年代：小编每次登陆王者荣耀，还有每次登陆刺激战场Z！ 看着里面的聊天界面，各种代打、各种的找cp。小小编觉得，我们已经失去了玩游戏的初心
c# 游戏实例 炸弹人 源码（大学时期作品）
06-20
本人大学时期作品，在其他地方绝对找不到，源码，有注释。
通达信 今日曾经涨停编写
06-08
通达信的今日曾经涨停可以通过以下公式来判断： COUNT(C >= REF(C, 1) * 1.1 AND REF(C, 1) < REF(C, 2), 1) 其中，C表示当日的收盘价，REF(C, 1)表示昨日的收盘价，1.1表示涨停板的上限，REF(C, 1) * 1.1表示昨日的涨停板价位，REF(C, 1) < REF(C, 2)表示昨天不是连续涨停。 以上公式的含义是：当日的收盘价大于昨日的涨停板价位，且昨天没有连续涨停，就视为今日曾经涨停。 可以将以上公式保存为一个自定义的通达信公式，然后在股票代码的K线图上应用该公式进行查看。
评论 583
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

呆呆敲代码的小Y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值