管理游戏对象的创建

无论是编写应用还是 3D 游戏，都需要确保定期删除未使用的对象以避免程序过载。子弹在射出后就不那么重要了，但此类对象仍存在于关卡中与其发生碰撞的对象和墙体的附近。这种射击机制会导致场景中存在成百上千颗子弹，这不是我们想要的效果。

实践:销毁子弹

为了达到目的，我们可以想办法让子弹执行自身的销毁行为。

(1)在Scripts文件夹中创建一个新的C#脚本，命名为 BulletBehavior。

(2)拖放 BulletBehavior 脚本至 Prefabs 文件夹中的Bullet预制体上。

(3)在BulletBehavior 脚本中添加如下代码:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class BulletBehavior : MonoBehaviour 
{
    public float onscreenDelay = 5f;
  void Update () 
    {
        Destroy(this.gameObject, onscreenDelay);
  }
}

下面对步骤(3)中的代码进行解释

声明一个 float 变量来保存 Bullet 预制体实例化之后要在场景中保留的时间

使用 Destroy 方法删除GameObject。

Destroy 方法始终需要一个对象作为参数，在本例中，可使用 this 关键字指定脚本被附加到的对象
Destroy 方法还能使用可选的 float 参数来表示延迟时间，从而使子弹在屏幕上保留一小段时间。

刚刚发生了什么

Bullet 预制体会在指定的延迟时间过后从场景中销毁自身。这意味着子弹会执行自身定义的行为，无须其他脚本干预，这是对“组件”设计模式的理想应用。第 12章将讨论更多相关内容。

游戏管理器

学习编程的常见误区是把所有变量都设置为公共的。根据经验，首先应考虑将变量设为受保护的或私有的，仅当必要时再设为公共的。有经验的程序员会通过管理类来保护数据，为了养成好习惯，我们也会这样做。可以将管理类理解为安全访问重要变量和方法的通道。

pub

在编程中讨论安全性听起来有些奇怪。然而，当不同的类互相访问并更新数据时，事情会变得一团糟。只保留单个诸如管理类的联系点，可使影响变得最小。

维护玩家属性

Hero Bom 是一款十分简单的游戏，需要维护的数据只有两项:一是玩家收集了多少物品:二是玩家还剩多少生命值。可将这些变量设为私有的，使它们只能由管理类修改以保证受控且安全。

实践:创建游戏管理器

游戏管理类对于将来开发任何项目都是必需的，我们先来学习如何合适地创建游戏管理类。

(1)在 Scripts 文件夹中创建一个新的 C#脚本，命名为 GameBehavior。通常来说这个脚本应该命名为GameManager，但是 Unity 保留了这个名称供自己使用。

(2)在 Hicrarchy 面板中使用 Create Create Empty 创建一个空对象并命名为GameManager。然后向 GameManager 空对象附加GameBehavior 脚本，

(3)添加如下代码至GameBehavior 脚本中:

public class GameBehavior : MonoBehaviour
{
 private intitemsCollected = 0;
private int_playerHP = 10;
}

上述代码添加了两个私有变量来保存拾取的物品数量以及玩家剩余的生命值，设置为私有的是因为它们只能由 GameBehavior 类修改。如果设为公共的，其他类可能会修改它们，导致其中存储的数据不正确。

get和set属性

我们已经设置好了管理类脚本与私有变量，如何从其他类访问这些私有变量呢?我们可以通过向 GameBehavior 类添加不同的公共方法来向私有变量传递新值，但是还有没有更好的办法呢?

在这种情况下，C#为所有变量提供了 get 和 set 属性，从而完美地满足了现在的需求。可以将这些属性理解为由 C#编译器自动触发的方法,而无论是否显式地调用它们就像场景刚开始时 Unity 自动执行的 Start和Update方法一样。

get 和 set 属性能被添加至任何变量，包含或不包含初始值皆可:

public string firstName {get; set;};

或

public string lastName {get; set;}= "Smith";

然而，仅仅这样使用没有任何附加效果;为此，需要让每个属性包含一个代码块

public string FirstName
{
 get 
{
  // Code block executes when variable is accessed
}
set 
{
  // Code block executes when variable is updated
}
}

然而，仅仅这样使用没有任何附加效果;为此，需要让每个属性包含一个代码块

public string FirstName
{
 get 
{
  // Code block executes when variable is accessed
}
set 
{
  // Code block executes when variable is updated
}
}

现在，根据变量使用的位置，get 和 set 属性会执行附加逻辑。由于还没有完成全部工作，因此仍然需要处理这些新的逻辑。

每个get代码块都需要返回一个值，而每个set代码块则需要赋予一个值，这里正是结合使用私有变量(称为后备变量)和具有 get 及 set 属性的公共变量的好地方。私有变量将受到保护，其他类则可以受控访问公共变量。

private string firstName
public string FirstName 
{
  get 
  {
   return _firstName;
  } 
 set
  {
   _firstName=value;
  }
}
}

下面对上述代码进行解释。

任何时候，当其他类需要时，可以使用 get 属性返回存储在私有变量中的值下面对上述代码进行解释。而不需要实际将变量暴露给外部类。
任何时候，当使用外部类给公共变量赋值时，可以更新私有变量，使二者同步

不进行实际应用，上述解释阅读起来会有点深奥。可利用已有的私有变量，GameBehavior脚本，添加具有 get 和 set 属性访问器的公共变量。

实践:添加后备变量

你已经理解了 get 和 set 属性访问器的语法，下面在管理类中实现它们，从而使代码更高效、更具可读性。

按如下所示修改GameBehavior脚本中的代码:

public class GameBehavior : MonoBehaviour
{
  private int _itemsCollected = 0;
  public int Items
  {
   get { return _itemsCollected;}
   set 
   {
    _itemsCollected = value ;
    Debug.LogFormat("Items:{0}",_itemsCollected);
   }
  }
   private int_playerHP = 3;
   public int HP
 {
  get { return _playerHP; }
  set{
   _playerHP = value;
   Debug.LogFormat("Lives:{0}",_playerHP);
   }
  }
}

下面对上述代码进行解释。

声明名为 Items 的公共变量，其中包含 get 和 set 属性。

外部类访问 Items 变量时，使用 get 属性返回存储于 itemsCollected 中的值。

使用sct 属性在 lcms 变量被更新时为 itemCollected 赋新值，同时添加Debug.LogFormat 方法以打印修改后的 itemsCollected 的值。

设置具有get和set 属性的公共变量HP，从而对后备变量 playerHP 进行补充

刚刚发生了什么

GameBehavior脚本的两个私有变量现在都可以访问了，但是仅允许访问公开的部分。这确保了私有变量只能在特定的位置进行访问和修改。

实践:更新物品集合

我们已经设置好了 GameBehavior 脚本中的变量，每次在场景中收集 Pickup_Item时都可以更新Items变量。

(1)在ItemBehavior脚本中添加如下代码:

public class ItemBehavior : MonoBehaviour
{
void Start()
{
  gameManager = GameObject.Find("GameManager").GetComponent<GameBehavior>();
}
void OnCollisionEnter(Collision collision)
{
  if (collision.gameObject.name == "Player")
  {
   Destroy(this.transform.parent.gameObject);
   Debug.Log("Item collected!");
   gameManager.Items += 1;
}
}
}

(2)运行游戏并收集物品,查看管理类脚本输出到控制台中的信息

下面对步骤(1)中的代码进行解释。

创建一个GameBehavior类型的变量来保存对脚本的引用。

在Start 方法中，使用 Find 方法查找对象并添加 GetComponent 方法以初始化gameManager。

当Pickup_Item 对象被销毁后，就在 gameManager 中增加Items 属性的值

刚刚发生了什么

由于已经在 ItemBehavior 类中处理好了碰撞逻辑，因此我们可以很容易地修改onolisionEnter 方法，从而在玩家拾取物品时与管理类进行沟通。将功能分离能使代召更具弹性，在开发期间进行修改时出错的可能性也会降低。

精益求精

目前，多个脚本共同配合，进而实现了玩家的移动、跳跃、收集、射击等机制。但是，现在仍然缺少用来展示玩家状态的显示内容或视觉提示，并且缺少游戏的胜败条件。本节将重点关注这两个主题。

图形用户界面

用户界面是任何计算机系统都有的可视组件，通常称为 UI。鼠标指针、文件夹以及桌面上的程序图标都是 UI元素。我们的游戏需要拥有简单的UI以使玩家知道已经集了多少物品以及当前的生命值，还需要一个能在发生特定事件时进行更新的文本框在Unity 中添加UI元素有两种方式:

直接使用 Hierarchy 面板中的 Create 菜单进行创建，就像创建其他游戏对象一样。
在代码中使用内置的 GUI类。

我们将一直使用代码方式，这么做并非因为代码方式优于另一种，而是为了与之前保持一致。

GUI类提供了一系列方法来创建和摆放组件,所有 GU方法都可在 MonoBehaviour脚本的OnGUI方法中进行调用。可以将 OnGUI方法理解为用于UI的 Update 方法.

实践:添加 UI 元素

目前还不需要向玩家显示很多信息,但是我们应该将需要显示的信息以令人愉悦引人注目的方式显示在屏幕上。

(1)按如下代码修改GameBehavior 脚本并收集物品:

public class GameBehavior : MonoBehaviour
{
  public string labelText = "Collect all 4 items and winyour freedom!";public int maxItems = 4;
  private int _itemsCollected = 0;
  public int Items
{
   get { return _itemsCollected; }
   set{_itemsCollected = value;
   if(_itemsCollected >= maxItems)
   {
     labelText = "You've found all theitems!";
   }
   else
   {
    labelText = "Item found, only " + (maxItems-_itemsCollected) + " more to go!";
   }
}
}
 private int _playerLives =3;
 public int Lives
{
 get { return _playerLives;}
 set {
     _playerLives = value;
Debug.LogFormat("Lives:(0)，_playerLives);
}
}
void OnGUI()
{
  GUI.Box(new Rect(20，20，150，25)，"Player
Health:"+_playerLives);
   GUIBox(new Rect(20，50，150，25)，nItemsCollected: + _itemsCollected);
  GUI.Label(new Rect(Screen.width / 2 - 100,Screen.height - 50，300，50)，labelText);
}
}

(2) 运行游戏，用户界面

下面对步骤(1)中的代码进行解释。

创建两个公共变量:一个表示要在屏幕底部显示的文本;另一个表示关卡中品的最大数量。

在itemsCollected变量的set 属性中声明一条if语句。

如果玩家收集的物品的数量大于或等于 maxItems，那么玩家赢得游戏并目回顾第6新 labelText。
否则，使用 labelText 显示还需要收集多少物体。

声明OnGUI方法以包含UI代码。

通过指定位置、大小与字符串信息来创建 GUIBox 方法

Rect 类的构造函数将接收宽度和高度值作为参数。
Rect对象的起始位置始终为屏幕的左上角。
使用new Rect(20.20.150.25)可创建一个位于场景左上角的2D方框距离场景的左侧边界 20 像素，距离顶部边界也 20 像素，宽度为 150像素，高度为25像素。

在生命值方框的下面创建另一个方框以显示当前的物品数量

在屏幕的底部创建一个标签以显示 labelText

因为OnGUI方法每帧至少会执行一次，所以在任何时候当abelText的值发生变化时，都会在屏幕上进行更新。
这里使用Screen类的width和height属性获取绝对位置而不是手动计赛展幕的中心位置。

刚刚发生了什么

当我们运行游戏时，三个UI元素都显示了正确的值。每当收集一个Pickup llem时，lableText和 itemsCollected 都会得到更新

胜败条件

游戏的核心机制与简易UI都已实现,Hero Bom游戏还缺少如下重要的射击元素胜败条件。胜败条件用于管理玩家赢得游戏还是失败，并根据情况执行不同的代码

收集关卡中的所有道具且生命值至少为1时胜利。
受到敌人伤害且直到生命值变为0时失败。

以上条件会影响 UI以及游戏机制，但这些都已在 GameBehavior 脚本中高效处理过了。get和 set 属性会处理任何游戏相关逻辑，而GUI方法则会在玩家胜利或失败时改变UI。

实践:赢得游戏

为了给玩家带来清晰且即时的反馈，下面从添加胜利条件的逻辑开始。

(1)按如下代码修改GameBehavior 脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using CustomExtensions;
public class GameBehavior : MonoBehaviour, IManager
{
    public string labelText = "Collect all 4 items and win your freedom!";
    public readonly int maxItems = 4;
    public bool showWinScreen = false;
    public bool showLossScreen = false;
    public delegate void DebugDelegate(string newText);
    public DebugDelegate debug = Print;
    private string _state;
    public string State 
    {
        get { return _state; }
        set { _state = value; }
    }
    private int _itemsCollected = 0;
    public int Items
    {
        get { return _itemsCollected; }
        set { 
            _itemsCollected = value;
            if (_itemsCollected >= maxItems)
            {
                labelText = "You've found all the items!";
                showWinScreen = true;
                Time.timeScale = 0;
            }
            else
            {
                labelText = "Item found, only " + (maxItems - _itemsCollected) + " more to go!";
            }
        }
    }
    private int _playerLives = 3;
    public int Lives 
    {
        get { return _playerLives; }
        set { 
            _playerLives = value; 
            if(_playerLives <= 0)
            {
                labelText = "You want another life with that?";
                showLossScreen = true;
                Time.timeScale = 0;
            }
            else
            {
                labelText = "Ouch... that's got hurt.";
            }
        }
    }
    void Start()
    {
        Initialize();
        InventoryList<string> inventoryList = new InventoryList<string>();
        inventoryList.SetItem("Potion");
        Debug.Log(inventoryList.item);
    }
    public void Initialize() 
    {
        _state = "Manager initialized..";
        _state.FancyDebug();
        debug(_state);
        LogWithDelegate(debug);
        PlayerBehavior playerBehavior = GameObject.Find("Player").GetComponent<PlayerBehavior>();
        playerBehavior.playerJump += HandlePlayerJump;
    }
    public void HandlePlayerJump(bool isGrounded)
    {
        if(isGrounded)
        {
            debug("Player has jumped...");
        }
    }
    public static void Print(string newText)
    {
        Debug.Log(newText);
    }
    public void LogWithDelegate(DebugDelegate debug)
    {
        debug("Delegating the debug task...");
    }
  void OnGUI()
  {
        GUI.Box(new Rect(20, 20, 150, 25), "Player Health: " + _playerLives);
        GUI.Box(new Rect(20, 50, 150, 25), "Items Collected: " + _itemsCollected);
        GUI.Label(new Rect(Screen.width / 2 - 100, Screen.height - 50, 300, 50), labelText);
        if (showWinScreen)
        {
            if (GUI.Button(new Rect(Screen.width/2 - 100, Screen.height/2 - 50, 200, 100), "YOU WON!"))
            {
                Utilities.RestartLevel();
            }
        }
        if(showLossScreen)
        {
            if (GUI.Button(new Rect(Screen.width / 2 - 100, Screen.height / 2 - 50, 200, 100), "You lose..."))
            {
                try
                {
                    Utilities.RestartLevel(-1);
                    debug("Level restarted successfully...");
                }
                catch (System.ArgumentException e)
                {
                    Utilities.RestartLevel(0);
                    debug("Reverting to scene 0: " + e.ToString());
                }
                finally
                {
                    Utilities.RestartLevel(0);
                    debug("Restart handled...");
                }
            }
        }
  }
}

(2)在Inpsector 面板中将Max Items 修改为1，然后进行测试，

下面对步骤(1)中的代码进行解释。

创建一个新的布尔变量来维护胜利界面出现的时机。

当玩家收集完所有物品时，在 Items 对象的set 属性中将showWinScreen 设置为true。

在OnGU方法的内部使用 if 语句检查胜利界面是否应该显示

在屏幕的中央创建一个可单击的按钮。

GULBumon 方法将返回一个布尔值，当这个按钮被单击时返回 true，否则返回
false.
在i语句中调用GULButton 方法，从而当这个按钮被单击时执行f语句的语句体

刚刚发生了什么

maxItems 被设置为1，胜利按钮会在收集完场景中唯一的 Pickup Item 后出现

但是现在单击这个按钮不起任何作用，

使用预编译指定和命令空间

胜利条件可以按预期方式运行了，但是胜利后，玩家仍然可以控制胶囊，而且游戏一旦结束，尚没有办法重新开始。Unity 的 Time 类提供了 timeScale 属性，当这属性被设置为 0 时就会暂停整个游戏。为了重新开始游戏，我们需要访问命名空间SceneManagement。默认情况下，这个命名空间还无法从我们的类中直接访问。

命名空间可以将一系列类包含在某个特定的名称下，进而组织大型项目并避免共用相同名称的脚本间产生冲突。可通过向类中添加 using 指令以访问另一个命名空间中的类。

所有通过 Unity创建的C#脚本都包含如下三条默认的 using 指令:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

这样就可以访问常用的命名空间了。Unity 和 C#提供了非常多的功能，可以通过在关键字 using之后加上命名空间的名称来进行添加。

实践:暂停与重启游戏

我们的游戏需要在玩家胜利或失败时能够暂停和重启。为此，我们需要引入新建的C#脚本默认都不会包含的命名空间。

在GameBehavior脚本中添加如下代码并运行游戏。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using CustomExtensions;
public class GameBehavior : MonoBehaviour, IManager
{
    public string labelText = "Collect all 4 items and win your freedom!";
    public readonly int maxItems = 4;
    public bool showWinScreen = false;
    public bool showLossScreen = false;
    public delegate void DebugDelegate(string newText);
    public DebugDelegate debug = Print;
    private string _state;
    public string State 
    {
        get { return _state; }
        set { _state = value; }
    }
    private int _itemsCollected = 0;
    public int Items
    {
        get { return _itemsCollected; }
        set { 
            _itemsCollected = value;
            if (_itemsCollected >= maxItems)
            {
                labelText = "You've found all the items!";
                showWinScreen = true;
                Time.timeScale = 0;
            }
            else
            {
                labelText = "Item found, only " + (maxItems - _itemsCollected) + " more to go!";
            }
        }
    }
    private int _playerLives = 3;
    public int Lives 
    {
        get { return _playerLives; }
        set { 
            _playerLives = value; 
            if(_playerLives <= 0)
            {
                labelText = "You want another life with that?";
                showLossScreen = true;
                Time.timeScale = 0;
            }
            else
            {
                labelText = "Ouch... that's got hurt.";
            }
        }
    }
    void Start()
    {
        Initialize();
        InventoryList<string> inventoryList = new InventoryList<string>();
        inventoryList.SetItem("Potion");
        Debug.Log(inventoryList.item);
    }
    public void Initialize() 
    {
        _state = "Manager initialized..";
        _state.FancyDebug();
        debug(_state);
        LogWithDelegate(debug);
        PlayerBehavior playerBehavior = GameObject.Find("Player").GetComponent<PlayerBehavior>();
        playerBehavior.playerJump += HandlePlayerJump;
    }
    public void HandlePlayerJump(bool isGrounded)
    {
        if(isGrounded)
        {
            debug("Player has jumped...");
        }
    }
    public static void Print(string newText)
    {
        Debug.Log(newText);
    }
    public void LogWithDelegate(DebugDelegate debug)
    {
        debug("Delegating the debug task...");
    }
  void OnGUI()
  {
        GUI.Box(new Rect(20, 20, 150, 25), "Player Health: " + _playerLives);
        GUI.Box(new Rect(20, 50, 150, 25), "Items Collected: " + _itemsCollected);
        GUI.Label(new Rect(Screen.width / 2 - 100, Screen.height - 50, 300, 50), labelText);
        if (showWinScreen)
        {
            if (GUI.Button(new Rect(Screen.width/2 - 100, Screen.height/2 - 50, 200, 100), "YOU WON!"))
            {
                Utilities.RestartLevel();
            }
        }
        if(showLossScreen)
        {
            if (GUI.Button(new Rect(Screen.width / 2 - 100, Screen.height / 2 - 50, 200, 100), "You lose..."))
            {
                try
                {
                    Utilities.RestartLevel(-1);
                    debug("Level restarted successfully...");
                }
                catch (System.ArgumentException e)
                {
                    Utilities.RestartLevel(0);
                    debug("Reverting to scene 0: " + e.ToString());
                }
                finally
                {
                    Utilities.RestartLevel(0);
                    debug("Restart handled...");
                }
            }
        }
  }
}

下面对上述代码进行解释。

使用 using 关键字添加 SceneManagement 命名空间，Unity 提供的这个命名空间会处理所有场景相关的逻辑。

当胜利界面出现时，把 Time.timeScale 设置为0以暂停游戏，从而禁止任何输入和移动。

当单击胜利界面中的按钮时，调用 LoadScene 方法。

LoadScene 方法接收一个int 类型的参数来表示场景的索引。
因为项目中只有一个场景，所以使用索引0来重新开始游戏。

重新打开场景后，把Time.timeScale 重置为默认值 1，这样所有控件和行为就可以再次执行了。

刚刚发生了什么

现在，当玩家收集物品并单击胜利界面中的按钮时，关卡会重启，所有脚本和组件都会被重置为原始值并为下一轮游戏做准备。

总结

恭喜!从玩家的视角看，Hero Bor 游戏现在已处于可玩状态。我们实现了跳跃和射击机制，对物理碰撞进行了管理并生成了对象，还添加了少量的基础性 I 元素来给予反馈。你甚至可以在玩家胜利时重置关卡!

本章介绍了大量新的主题，一定要回顾并确保自己真的理解所写代码中发生了什么。尤其要掌握枚举、get 和 set 属性以及命名空间方面的知识。从本章开始，随着进步探究 C#语言，代码只会变得越来越复杂。

在第9章，我们将使敌人在与玩家距离过近时能够注意到玩家，从而执行跟随射击行为，以此增大玩家收集物品时的风险。

从零开始做一款Unity3D游戏＜三＞——编写游戏机制（二）

管理游戏对象的创建

游戏管理器

维护玩家属性

get和set属性

精益求精

图形用户界面

胜败条件

使用预编译指定和命令空间

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景