溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章給大家分享的是有關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控制腳本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如何實現炸彈人游戲”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
