4.5 游戏界面_Unity游戏案例开发大全-QQ阅读男生玄幻网

上QQ阅读APP看书，第一时间看更新

4.5 游戏界面

在上一节中已经介绍过了主菜单界面的开发过程，本节将要介绍的游戏界面是本游戏开发的中心场景，其他的场景都是为此场景服务的，游戏场景的开发对于此游戏的可玩性有至关重要的作用。本节将对此界面的开发进行进一步的介绍。

4.5.1 基本场景搭建

游戏场景搭建主要是针对游戏地图、灯光、天空盒等环境因素的设置。通过本节的学习，读者将会了解如何构建出一个基本的游戏世界，接下来将具体介绍场景的搭建步骤。

（1）新建场景。选择“File”→“New Scene”，然后选择“File”→“Save Scene”选项（或者Ctrl+S），在保存对话框中输入场景名“GameScene”，如图4-24所示。

▲图4-24 新建场景

（2）创建光源。选择“GameObject”→“Create Other”→“Directional Light”选项后会自动创建一个定向光源，如图4-25所示。

▲图4-25 创建光源

（3）为灯光添加太阳效果。选择“Assets”→“Import Package”→“Light Flares”选项，导入灯光特殊效果资源包。选择刚才创建的“Directional Light”，然后将此灯光的Flare属性设置为50mm Zoom，当摄像机面向太阳的时候，会出现太阳的光晕效果，如图4-26所示。

▲图4-26 为灯光添加太阳效果

（4）创建地图。创建空物体取名“Map”，用以对所有地图资源进行管理，然后将地图模型Map.fbx拖进场景，并使其成为刚才创建的Map对象的子物体。

（5）将地图的俯视图添加进场景。创建一个空的GameObject，改名为“MiniMap”，调整Transform使其位于合适位置。单击“Add Component”→“Mesh”→“Mesh Renderer”按钮，然后将Mesh Renderer的属性设置如下，如图4-27所示。

▲图4-27 制作俯视图

（6）设置地图模型的边界。创建空的GameObject，改名为“MapCollider”，然后创建四个子物体，为其添加Box Collider，调整各自位置使其处于地图的四个边缘，以防止玩家走到地图的外面。图4-28所示为创建完成之后的效果。

▲图4-28 设置地图Collider

（7）添加天空盒。首先应该从Assets中导入Skyboxes资源包，然后单击“Edit”→“Render Settings”，打开RenderSettings属性窗口，设置Skybox Material属性为Sunny1 Skybox，如图4-29所示。至此，基本的场景搭建完毕。

▲图4-29 添加天空盒

4.5.2 炸弹的创建

上一小节已经介绍了场景的搭建过程，本小节将对游戏中炸弹的创建以及其相关脚本的编写进行详述，其具体的讲解内容如下。

（1）创建一个空物体，改名为“Bomb”。创建两个空物体，取名为“PointA”和“PointB”，调节他们两个位置，使其处于地图上的不同位置，分别代表炸弹的两个不同位置，本游戏的炸弹位置将随机创建在PointA或者PointB之中。

（2）将bomb.fbx模型拖动到场景之中，使其成为Bomb的子物体。创建脚本“BombCtrl.cs”，并拖动到Bomb下面的minebot_head对象上面。在Start函数中随机计算炸弹的位置。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/BombScripts/目录下的BombCtrl.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class BombCtrl : MonoBehaviour {
      4        ........//此处省略了其他变量和方法的声明，将会在下面给出
      5        public Transform bomb;                                 //炸弹对象引用
      6        public Transform bombA;                                //安装炸弹的A点
      7        public Transform bombB;                                //安装炸弹的A点
      8        void Start () {
      9             if((int)(Random.value*1.999f) == 0) {             //随机数等于零时
      10                  bomb.position = bombA.position;             //将炸弹安装在A点
      11            }
      12            else {
      13                  bomb.position = bombB.position;             //将炸弹安装在B点
      14       }}
      15       ......//此处省略了Update方法，将在下面介绍
      16       ......//此处省略了OnExplode方法，将在下面介绍
      17  }

说明

BombCtrl类声明了炸弹对象引用、炸弹地点的A地和B地的Transform，在Start函数中，每次产生一个随机数，以使炸弹的位置不固定。读者也可以多声明几个地点Transform，来让炸弹有更多的地点可选值。

（3）前面介绍了炸弹位置的初始化，接下来介绍Update方法的编写，此函数用于实现炸弹的闪烁效果。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/BombScripts/目录下的BombCtrl.cs。

      1   void Update () {
      2        if(isExplode) {                                         //如果爆炸标志位为真
      3              return;                                           //返回避免下面的代码执行
      4        }
      5        timeLevel = 1- currentTime.GetTime()/currentTime.totalTime;   //计算时间
      6        float deltaBlink = 1/Mathf.Lerp (2, 15, timeLevel); //计算每次闪烁和播放音效的时间间隔
      7        if (Time.time > lastBlinkTime + deltaBlink) {     //当超过时间间隔的时候
      8              lastBlinkTime = Time.time;                       //得到当前时间
      9              Blink();                                          //调用方法
      10           if (CameraAdaption.sound)   {                      //如果可播放声音
      11                 audio.clip = bombWarningClip;               //指定音效
      12                 audio.Play();                                //播放警报音效
      13  }}}
      14. void OnWillRenderObject () {                                //系统回调方法
      15       renderer.sharedMaterial.SetFloat(
      16           "_SelfIllumStrength", blink);//设置炸弹材质着色器中的_SelfIllumStrength变量
      17  }
      18  void Blink () {
      19       blink = 1.0f - blink;                                  //计算闪烁
      20  }

第2行～第4行用以检测炸弹是否爆炸，如果爆炸则返回。第5～第13行差值计算炸弹闪烁的时间间隔和音效速度，如果当前允许播放声音，还会播放“嘀嘀嘀”的警报音效。

第14行～第17行是Unity系统的一个回调函数，此函数每次都会在物体的Shader改变之后，进行回调重新渲染此物体。通过不停得对blink值进行计算，实现炸弹的闪烁效果。其中，Shader脚本使用的是Unity官方demo“Angry Bots”中的“EnemySelfIlluminationReflective.shader”。

（4）前面介绍了Update方法，接下来编写OnExplode方法，用以实现炸弹爆炸的效果。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/BombScripts/目录下的BombCtrl.cs。

      1   void OnExplode () {
      2        isExplode = true;                                      //设置标志位
      3        GameObject exploEffect =                               //实例化粒子系统
      4           Instantiate(explodePrefab, Vector3.zero, Quaternion.identity) as GameObject;
      5        exploEffect.transform.parent = this.transform;        //设置effect的父节点
      6        exploEffect.transform.localPosition = Vector3.zero;   //设置在父节点的位置
      7        explodeEffect = exploEffect.particleEmitter;          //设置damageEffect
      8        if (CameraAdaption.sound){                             //如果可播放声音
      9              audio.clip = explodeAudioClip;
      10             audio.Play();                                    //播放警报音效
      11       }
      12       explodeEffect.Emit();                                  //发射爆炸粒子特效
      13       bombMeshRenderer.enabled = false;                      //将炸弹隐藏
      14       Destroy(gameObject,3.74f);                             //3.74秒后销毁炸弹
      15  }

第3行～第7行实例化一个粒子爆炸特效对象，设定粒子特效所在的父对象，并设置位置使其处于炸弹上，然后第12行则调用Emit函数播放粒子特效，实现炸弹的爆炸效果。

第8地～第11行为如果当前允许播放声音，则将音频赋值为炸弹爆炸的音效，并且播放声音。第13行～第14行实现的效果是炸弹爆炸之后，禁用炸弹的Renderer渲染，以达到隐藏炸弹的效果，然后隔3.74秒之后销毁炸弹对象。

（5）为炸弹添加Trigger。通过一直按住发射子弹按钮来进行拆除炸弹，因此当玩家进入Trigger的时候，需要使玩家的枪不再具有开枪效果。选中Bomb，在属性窗口中勾选Is Trigger标志位，然后调节Size大小，当玩家进入这个范围的时候，将调用Trigger相应方法，如图4-30所示。

▲图4-30 为炸弹添加trigger

（6）在给炸弹添加指定大小的Trigger后，编写脚本“DefuseBomb.cs”，在OnTriggerStay和OnTriggerExit分别实现对玩家进入Trigger进行拆弹和离开Trigger之后的操作。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/BombScripts/目录下的DefuseBomb.cs。

    1   using UnityEngine;
    2   using System.Collections;
    3   public class DefuseBomb : MonoBehaviour {
    4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
    5   void OnTriggerStay(Collider other) {                        //当玩家进入拆弹范围时
    6        if (GameObject.FindWithTag("Enemy")){                  //当敌人没有消灭干净时
    7             return;                                            //不允许拆弹
    8        }
    9        if (other.gameObject.tag == "Player") {                //如果是玩家碰撞
    10             crosshairScript.canShowCrosshair = false;       //不允许显示十字瞄准线
    11             weaponManager.selectedWeapon.defusingBomb = true;//拆弹标志位设为true
    12             bombProgressBar.SetActive(true);                 //显示拆弹进度条
    13             if(Application.platform == RuntimePlatform.Android ||//在手机平台上时
    14                  Application.platform == RuntimePlatform.IPhonePlayer) {
    15                  startDefuseBomb = fireBtn.defuseBomb;      //按住开枪按钮为拆弹操作
    16             }
    17             else {                                            //在PC上
    18                  startDefuseBomb = Input.GetMouseButton(0); //按住鼠标左键为拆弹操作
    19             }
    20             if(startDefuseBomb) {                            //按住鼠标左键
    21                  tempTime = Mathf.Lerp(tempTime, 1, speed * Time.deltaTime);//计算按住的时间
    22             }
    23             else {                                            //松开鼠标时间又慢慢减少
    24                  tempTime = Mathf.Lerp(tempTime, 0, speed * Time.deltaTime);
    25             }
    26             if(tempTime>0.99f) {                             //当进度条大于0.99时
    27                  tempTime = 1;                               //将进度条的值设为1
    28                  gameWin.SendMessage("GameWin",              //发送游戏胜利消息
    29                      SendMessageOptions.RequireReceiver);
    30             }
    31             foreground.fillAmount = tempTime;                //改变进度条的值
    32   }}
    33   void OnTriggerExit(Collider other) {                       //如果玩家远离拆弹范围时
    34      if (other.gameObject.tag == "Player") {                //如果是玩家碰撞
    35             crosshairScript.canShowCrosshair = true;        //允许显示十字瞄准线
    36             weaponManager.selectedWeapon.defusingBomb = false;   //拆弹标志位为false
    37             tempTime = 0;                                    //将拆弹进度设置为0
    38             bombProgressBar.SetActive(false);                //隐藏拆弹进度条
    39   }}

第9行～第32行实现当玩家进入Trigger，按住鼠标左键或者开枪按钮不放的时候，激活拆弹进度条。在此差值计算用户按住按钮的时间，实现按住时间越长进度条走动越慢的效果。将差值后的变量赋值给进度条的fillAmount属性，使进度条增长。

第33行～第39行当玩家离开Trigger的时候，将拆弹标志位设置为false，并且隐藏拆弹进度条，同时允许玩家在开枪的时候，单击鼠标左键能够显示十字瞄准线效果。

4.5.3 敌人的创建

搭建游戏界面场景的步骤比较繁琐，由于篇幅的限制这里不能很详细地介绍每一个细节，所以，要求读者对Unity的基础知识有一定的了解。接下来对游戏界面的开发步骤进行具体的介绍。

（1）为了方便对所有的敌人进行统一管理，首先新建一个空的GameObject，改名为“Enemys”。选中Enemys，再新建一个空的GameObject，改名为“Enemy”。之后选中“Enemy”，再创建一个空的GameObject，改名为“Enemy”，并为其添加RigidBody和Audio Source组建。

（2）导入敌人模型。拖动“robot.fbx”到Enemy下面，可以看到在Enemy下面多了一个“robot”对象。之后选中robot，调节Transform Size为“x：100，y：80，z：100”，放大模型。读者可看到头部有立方形物体，将其选中，然后去除Mesh Renderer即可，如图4-31所示。

▲图4-31 导入敌人模型

（3）为敌人添加眼睛。选中“headhandle”，即敌人头部，然后在下面创建子物体，并更名为“eyehandle”，然后为eyehandle添加Mesh Renderer组建和Mesh Filter组建，设置属性如图4-32所示，读者可根据需要将其缩小然后移动到敌人的眼睛部分即可，之后复制一个添加到另一个眼睛。

▲图4-32 为敌人添加眼睛

（4）读者可能注意到敌人枪部分没有贴图。这个时候应该展开robot→mover→gun→ammo对象节点，选中ammo，将Shader属性改为“Mobile/Diffuse”，然后选择“Red 1”材质即可，如图4-33所示。

▲图4-33 添加刚体的参数

（5）为了使敌人的眼睛实现闪烁的效果，编写脚本“EyeBlink.cs”。此脚本通过间歇性地控制Shader脚本中的“_Color”属性来动态地实现敌人眼睛闪烁的效果。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts目录下的EyeBlink.cs。

        1   using UnityEngine;
        2   using System.Collections;
        3   public class EyeBlink: MonoBehaviour {
        4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
        5   void Update () {
        6        if (Time.time - lastBlinkTime >= 1) {                      //时间间隔大于1秒
        7              lastBlinkTime = Time.time;                            //记录上次闪烁时间
        8              blink = 1- blink;                                    //改变blink值
        9              gameObject.renderer.material.SetColor("_Color",
        10                      new Color(1,0,0,blink));                     //设置_Color属性值
        11  }}

说明

在Update函数中，每隔1秒便改变一次Blink值，以使Shader脚本中的“_Color”变量动态地改变，达到闪烁的效果。

（6）给枪口添加粒子特效。单击robot→mover→gun→gun_model，然后新建一个空物体“gun_muzzle_Object”，在这个空物体下面再新建一个物体“gun_muzzle_partcal”，调节gun_muzzle_partcal的位置，使其位于枪口的位置。然后添加粒子，设置属性如图4-34所示。

▲图4-34 枪口粒子特效的设置

（7）调整gun_muzzle_Object对象的位置，使其位于枪的中间位置，敌人的子弹将从这里实例化。为gun_muzzle_Object对象添加“Audio Source”，然后编写脚本“BlinkAndFire.cs”，在Update方法中控制枪口颜色的变化，以及对子弹的管理。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts目录下的BlinkAndFire.cs。

        1   using UnityEngine;
        2   using System.Collections;
        3   public class BlinkAndFire : MonoBehaviour{
        4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
        5   void Update () {
        6        pSystem.startColor=Color.Lerp(Color.red,Color.red/2,
        7                 Mathf.PingPong(Time.time, 1));      //不断改变枪口粒子特效的颜色
      8        if (firing){
      9              if (Time.time > lastFireTime + 1.52f){           //超过指定时间间隔
      10                   lastFireTime = Time.time;                  //记录上一次的发射时间
      11                   if (CameraAdaption.sound && fireSound){    //如果可以播放声音
      12                        audio.clip = fireSound;               //指定所需播放的声音
      13                        audio.Play();                         //播放警报音效
      14                   }
      15                   Instantiate(bulletPrefab,transform.position,transform.rotation);//实例化子弹
      16  }}}}

说明

在Update函数中，通过对粒子系统的startColor变量进行不断的差值来改变枪口粒子特效的颜色。当开枪的时候，如果当前允许播放声音，那么播放开枪的声音，然后在当前位置实例化一个子弹出来。

（8）创建子弹prefab。将Missile.fbx拖动到场景中，改变Mesh Renderer中的Materials为“Missile.mat”，为其添加一个“Audio Source”，按照图4-35所示设置属性即可。然后将子弹拖动到Assets/Models/Prefabs文件夹下，使其成为一个prefab。

▲图4-35 敌人子弹的设置

（9）编写脚本“SeekerBullet.cs”并且挂载到Missile对象上，此脚本主要控制子弹的位置，以及与玩家碰到之后所作出的反应。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/BombScripts目录下的SeekerBullet.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class SeekerBullet : MonoBehaviour {
      4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
      5   void Update () {
      6      ......//此方法省略了部分代码语句，查看详细代码请读者自行查询光盘
      7      if(targetObject) {                                       //如果获取到了Player对象
      8             Vector3 targetPos = targetObject.transform.position;//获取Player对象的位置
      9             targetPos = targetPos +
      10                      transform.right * (Mathf.PingPong(Time.time, 1.0f) -0.5f) *
                              noise;//使位置产生偏移
      11           Vector3 targetDir = targetPos - tr.position;      //计算两者的连线
      12           float targetDist = targetDir.magnitude;           //将向量归一化
      13           targetDir = targetDir/targetDist;
      14           if (Time.time - spawnTime < lifeTime * 0.2
      15                      && targetDist > 3) {//如果时间未超过生命的1/5，并且敌人与Player的距离还大于3
      16                targetDir = targetDir + transform.right * 0.5f * sideBias;//再次产生偏移量
      17           }
      18           dir = Vector3.Slerp(dir, targetDir, Time.deltaTime * seekPrecision);//计算导弹的朝向
      19           tr.rotation = Quaternion.LookRotation(dir);       //计算子弹的朝向
      20           tr.position = tr.position + (dir * speed) * Time.deltaTime;//计算到子弹位置
      21       }
      22       Collider[] hits = Physics.OverlapSphere(tr.position,
      23                  radius, ~ignoreLayers.value);               //检测是否碰到东西了
      24       foreach (Collider hit in hits) {
      25          Health targetHealth = hit.GetComponent("Health") as Health; //获取碰撞物体的Health脚本
      26          if (targetHealth) {                                 //如果脚本存在
      27                int damage = (int)Random.Range(damageAmount/2,damageAmount);//计算伤害大小
      28                targetHealth.OnDamage(damage, -tr.forward, tr.position, 0.5f);//受到伤害
      29          }
      30          collided = true;                           //子弹与Player相撞标志位置为true
      31       }
      32       if(collided) {
      33             Instantiate(explosionPrefab, tr.position, tr.rotation);//实例化爆炸特效
      34             Destroy(gameObject, 2);                 //两秒后销毁
      35             gameObject.renderer.enabled = false;   //禁止渲染
      36  }}}

第8行～第17行用以计算敌人子弹的朝向和实时位置，为了模拟更逼真的开枪射击效果，对子弹的射击点进行了一个位置扰动，即有时候打不中有时候能打中玩家，使敌人拥有一个正常人的行为思想。

第24行～第31行对子弹碰到的物体进行遍历，如果碰到玩家的话，那么调用挂载到玩家物体上的“Health.cs”脚本中的OnDamage方法，使玩家产生受伤效果。第32～第35行则实例化子弹爆炸模型，2秒之后销毁子弹对象。

（10）在Enemy下面，添加一个空物体AIAttack，然后编写脚本“SpiderAttackMoveController.cs”挂载到此对象上面，用以控制当玩家靠近敌人的时候，敌人移动的方向。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts目录下的SpiderAttackMoveController.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class SpiderAttackMoveController : MonoBehaviour {
      4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
      5   void FixedUpdate () {
      6        enemyMove.movementDirection = player.position - transform.position;//计算敌人的移动方向
      7   }}

说明

FixedUpdate函数的作用是不断地计算敌人的移动方向，永远朝着Player移动。

（11）同样，在Enemy下面，添加一个空物体AIReturn，然后编写脚本“SpiderReturnMoveController.cs”挂载到此对象上面，用以控制玩家远离敌人后，敌人自动回到原位置。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts目录下的SpiderReturnMoveController.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class SpiderReturnMoveController: MonoBehaviour {
      4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
      5   void Update () {
      6        float distance = (transform.position - targetPosition).sqrMagnitude;//计算距离的平方
      7        if (distance > 16) {                                   //如果没有回到起点
      8              enemyMove.movementDirection = targetPosition - transform.position; //计算敌人移动方向
      9        }
      10         else{
      11             enemyMove.movementDirection = Vector3.zero;     //不允许移动
      12             spiderAnimation.enemyIdle();                     //设置敌人静止不动的动画
      13             transform.parent.rotation = rotation;            //设置姿势为起始姿势
      14             enabled = false;
      15  }}}

第6行～第9行计算出敌人当前位置和初始距离的平方，targetPosition保存了敌人初始的位置，如果敌人没有回到起点，且敌人当前的位置与初始位置的距离大于4m，那么就一直计算敌人的移动方向。

第11行～第14行是当敌人处于初始点附近时，调整敌人姿态，并播放敌人闲时的动画。游戏不要求敌人必须回到原点，因此给的是一个距离初始点4m为半径的圆的范围。

（12）继续在Enemy下面创建新的一个Cube，改名为“AIShootSize”，然后去除掉Mesh Renderer前面的对勾，勾选Is Trigger选项，使其充当一个Trigger的作用，适当调节Box Collider的范围，如图4-36所示。

▲图4-36 设置射击范围

（13）编写脚本“ShootAI.cs”，并挂载到“AIShootSize”对象上，用以控制当玩家靠近或者远离敌人一定范围的时候，敌人执行相应的动作，即播放动画。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts/目录下的ShootAI.cs。

        1   using UnityEngine;
        2   using System.Collections;
        3   public class ShootAI: MonoBehaviour {
        4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
        5           void OnTriggerEnter(Collider other) {          //与该碰撞器相撞时的回调方法
        6                if(other.tag == "Player"){                //进入碰撞器范围的是玩家
        7                      spa.enemyShoot();                   //敌人开始射击
        8                      boxCollider.size =  boxSize * 1.5f; //放大射击范围
        9                      aiMoveOjb.SendMessage("OnShoot");   //发送正在射击消息
        10          }}
        11          void OnTriggerExit(Collider other) {           //玩家离开该范围时的回调方法
        12                if (other.tag == "Player"){
        13                      spa.enemyRun();                    //敌人跑步
        14                      boxCollider.size = boxSize;        //缩小范围
        15                      aiMoveOjb.SendMessage("OnSpotted1"); //使AIReturn的脚本可使用
        16  }}}

第5行～第10行，当Player走到Trigger范围内的时候，敌人则开始向玩家射击，故意放大了Trigger的范围，用以实现一种“易进难出”的效果，同时发送敌人当前正在开枪射击Player的消息。

第11行～第16行，当Player出去Trigger范围的时候，敌人开始执行跑步动作，即追踪Player，使敌人看起来更加智能，此时缩小Trigger的范围，同时发送消息，当条件满足的时候要返回原点不再追踪Player。

（14）选中Enemys对象下面的Enemy，然后新建一个Cube，改名为“AIMoveSize”，去除Mesh Renderer组建使其不渲染，同样勾选“Is Trigger”属性，使其成为一个Trigger，并调节Size大小。

提示

AIMoveSize上面的Trigger范围控制的是敌人移动的范围，而AIShootSize上面的Trigger范围控制的是敌人攻击的范围。

（15）编写脚本“EnemyMove.cs”，此脚本是对AIReturn和AIAttack的一个管理类，主要控制敌人在不同情况下对玩家应该做出什么样的反应。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts/目录下的EnemyMove.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class EnemyMove: MonoBehaviour {
      4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
      5   void FixedUpdate(){
      6        facePlayer();                                           //让敌人面对Player
      7        if (!shoot){                                            //如果没有开枪
      8              Vector3 targetVelocity = movementDirection * walkingSpeed;//计算力的大小
      9              Vector3 dir = targetVelocity - character.rigidbody.velocity;//计算力的方向
      10             character.rigidbody.AddForce(dir * walkingSnappyness, ForceMode.Impulse); //给力
      11             if (Time.time > lastTime + 0.5f &&
      12                         movementDirection.sqrMagnitude > 1) {    //若时间大于指定间隔
      13                   if (CameraAdaption.sound) {                    //如果可播放声音
      14                         audio.clip = walkSounds;                 //设置声音播放片段
      15                         audio.Play();                             //播放声音
      16                   }
      17                   lastTime = Time.time;                           //重新计算时间
      18  }}}
      19  void facePlayer(){
      20       if(shoot){                                                       //如果正在开枪
      21            movementDirection = player.position - character.position;//计算移动方向
      22       }
      23       dir = Vector3.Slerp(dir, movementDirection, Time.deltaTime);   //计算朝向
      24       dir.y = 0;                                                       //设置y分量为0
      25       character.rotation = Quaternion.LookRotation(dir);             //面向目标点
      26  }}

第5行～第18行，在FixedUpdate函数中，首先让敌人面朝Player，当没有开枪的时候，根据走路的速度计算力的大小和方向，然后将此力施加在敌人身上使其移动，如果当前可播放声音，则播放走路声。

第19行～第26行，在facePlayer函数中，调整敌人的朝向dir、面向的目标点以及其他姿态，然后让敌人面向此dir方向。

（16）敌人血量的控制。编写脚本“Health.cs”，并挂载到Enemy对象上，此脚本用于使敌人在受到玩家开枪射击时侯血量减少，并且呈现出一种喷血效果。敌人受到伤害血量会减少，当敌人血量小于0时，敌人爆炸。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts/目录下的Health.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class Health: MonoBehaviour {
      4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
      5   public void OnDamage(int amount, Vector3 fromDirection,Vector3 damagePosition,float yOffer) {
      6       if (aiMoveObj){                                     //如果此脚本不为空
      7              aiMoveObj.SendMessage("OnAttack");          //发动攻击
      8       }
      9       if (dead){                                          //如果死了
      10             return;
      11       }
      12       health -= amount;                                  //血量减少
      13      if(transform.tag == "Player") {                    //如果是玩家
      14             bloodBar.CalLastBlood(amount);              //计算剩余血量
      15      }
      16       if(damageEffect) {                                 //如果粒子特效存在
      17            damageEffect.transform.rotation = Quaternion.LookRotation(fromDirection,Vector3.up);
      18            damagePosition.y += yOffer;
      19            damageEffect.transform.position = damagePosition - fromDirection.normalized/2;
      20            damageEffect.Emit();                         //喷射粒子
      21       }
      22       if(health <= 0) {                                  //如果血量少于0
      23            dead = true;                                  //死亡标志位为false
      24            if(transform.tag == "Player"){
      25                  gameObject.collider.enabled = false;
      26            }
      27            if (transform.tag == "Enemy"){
      28                  if (explorEffect) {                    //如果爆炸特效存在
      29                        explorEffect.transform.position=transform.position;//设置爆炸特效的位置
      30                        explorEffect.Emit();             //播放粒子特效
      31                  }
      32                  robot.SetActive(false);                //隐藏敌人
      33                  Destroy(gameObject.transform.parent.gameObject,1f);//1秒后摧毁
      34            }
      35            if(deadClip && CameraAdaption.sound) {       //如果可播放声音
      36                 audio.clip = deadClip;
      37                 audio.Play();                            //播放声音
      38  }}}}

第12行～第21行用于受到伤害的时候让血量减少，如果粒子特效存在，那么首先设置粒子特效的旋转角度和位置，接着调用Emit方法播放粒子特效，实现一种敌人或者Player受到伤害有血从身上喷出的效果。

第22行～第37行用于当血量减少到0的时候，将死亡标志位置为true。如果爆炸特效存在，那么首先设置特效的位置，接着播放爆炸特效并销毁模型资源。如果可播放声音，还会播放敌人或者Player在死亡时的声音。

提示

“Health.cs”脚本不光用来控制敌人血量的变化，也用来控制玩家血量的变化，通过检测脚本上面是否有“aiMoveObj”来区分当前是敌人还是玩家。

（17）编写敌人动画播放管理脚本。编写“SpiderAnimation.cs”并将其挂载到robot对象上，敌人模型中有三种动画：跑步、射击和敌人非忙碌时的动画。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/EnemyScripts/目录下的SpiderAnimation.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class SpiderAnimation: MonoBehaviour {
      4   ......//此处省略了其他函数和变量等的声明，请读者自行查阅光盘
      5          void OnEnable () {                              //设置各个动作为可用状态
      6                animation[idle.name].enabled = true;
      7                animation[idle.name].layer = 1;
      8                animation[idle.name].speed = 2;
      9                animation[run.name].enabled = true;
        10               animation[run.name].layer = 1;
        11               animation[shoot.name].enabled = true;
        12               animation[shoot.name].layer = 1;
        13               animation[shoot.name].speed = 0.5f;
        14               enemyIdle();                               //开始的时候为站立动作
        15          }
        16          public void enemyIdle(){                       //敌人闲时的动画
        17               gun_muzzle_Object.SetActive(false);        //隐藏枪
        18               animation.CrossFade(idle.name, 1f);       //切换到idle动画
        19               animation[idle.name].speed = 2;           //设置动画的播放速度
        20  }}

第5行～第15行，在OnEnable函数中，设置各个动画包括空闲、跑步、开枪射击的初始化状态信息，如是否可操作，所在层和播放速度等，接着调用enemyIdle函数。

第16行～第20行，在enemyIdle函数中，将敌人当前所拿的枪隐藏掉，然后播放idle动画。

（18）为敌人添加闪烁标志物。通过为敌人添加闪烁标志物，方便俯视摄像机对敌人的渲染，这样在小地图上将会把敌人的位置以点的形式呈现出来。在Enemy对象下面新建一个空物体“Target”，“Add Component”→“Effects”→“Legacy Particles”→“Ellipsoid Particle Emitter”，调节属性如图4-37所示。

▲图4-37 设置Ellipsoid Particle Emitter属性

（19）为Target对象添加“Particle Animator”，单击“Add Component”→“Effects”→“Legacy Particles”→“Particle Animator”，调节Size Grow属性为2，如图4-38所示。

▲图4-38 设置Particle Animator属性

（20）为Target对象添加“Particle Renderer”，“Add Component”→“Effects”→“Legacy Particles”→“Particle Renderer”，调节Size Grow属性为2，如图4-39所示。

▲图4-39 设置Particle Renderer属性

提示

Legacy Particle是Unity自带的一个用于实现特殊效果的粒子系统，读者可以通过它实现一些比较困难的特殊效果，使游戏的场景显示得更加逼真炫丽。

（21）设置Target所在的层，选中Target，在Inspector窗口中，添加一个新的Layer，取名为“Radar”，表示其只会被Culling Mask勾选上Radar层的摄像机渲染。最终效果如图4-40所示。

▲图4-40 敌人最终效果

提示

游戏中不止存在一个摄像机，为了节省资源，通过设置每个摄像机不同的Culling Mask指定其所需渲染的层，从而只使其指定层的物体呈现在游戏视野中，其他物体如敌人、枪支、武器等包括NGUI都设有自己所在的层（默认为Default），读者应多注意。

4.5.4 操作界面搭建

操作界面的搭建和主菜单界面的搭建一样，都是采用NGUI界面搭建的，主要负责显示一些对Player进行操作的按钮，如移动、蹲下、跳跃、瞄准、开枪、装弹和换枪，以及游戏剩余时间和剩余子弹的显示等。最终效果如图4-41所示。其主要的技术已经在本章第4节主菜单界面详细介绍过，此处不在详述。

▲图4-41 操作界面

4.5.5 Player的创建

上一小节介绍了敌人的制作过程，本小节将向读者介绍Player的创建，主要内容包括Player移动、切换视角、以及俯视图的制作。具体的开发步骤如下。

（1）单击“GameObject”→“Create Empty”按钮，选中并将其重命名为“Player”，为了方便管理，和Player人物相关的模型、操控等对象都放在这个父对象下面。

（2）创建Player的身体部分。选中“Player”，创建一个新的空物体，重命名为“Body”，然后在Body的属性窗口中，单击“Add Component”→“Mesh”→“Mesh Filter”，然后将Mesh属性改为“Capsule”，继续添加一个“Mesh Renderer”，将Materials改为“Default-Diffuse Material”，如图4-42所示。

▲图4-42 Player身体部分属性设置

（3）创建Player的头像部分。创建一个空物体“HeadLook”，使其成为“Player”的子物体。单击“Component”→“Create Other”→“Camera”，并将其更名为“Main Camera”，拖动使其成为“HeadLook”的子物体。此Camera是游戏的主摄像机，相当于Player的眼睛。属性设置如图4-43所示。

▲图4-43 摄像机属性设置

（4）创建武器界面摄像机。在“Main Camera”下面继续创建一个“Camera”，重命名为“Weapon Camera”。此Camera只渲染玩家所持的枪模型，删除默认携带的组件“Audio Listener”、“GUI Layer”、“Flare Layer”，并将“Clear Flags”改为“Depth Only”。属性设置如图4-44所示。

▲图4-44 武器摄像机设置

（5）屏幕自适应。游戏在移动手机平台上默认的屏幕分辨率为800×400，为了使游戏在不同大小的屏幕上显示正常，在此需要解决游戏屏幕自适应的问题。编写脚本“CameraAdaption.cs”，挂载到“Main Camera”上，脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/GameUIScripts目录下的CameraAdaption.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class CameraAdaption : MonoBehaviour{
      4       ......//此脚本省略了部分变量的声明，请读者自行查询光盘
      5       public static float desiginWidth = 800.0f;                  //标准屏幕的宽
      6       public static float desiginHeight = 480.0f;                 //标准屏幕的高
      7        void Awake(){
      8       ......//此方法省略了部分代码，请读者自行查阅光盘
      9       camera.aspect = 800.0f/480.0f;                              //设置视口的缩放比
      10      float lux = (Screen.width –                                 //计算视口偏移量
      11          CameraAdaption.desiginWidth * Screen.height/CameraAdaption.desiginHeight)/2.0f;
      12      camera.pixelRect = new Rect(lux, 0, Screen.width -2 * lux, Screen.height);//设置显示区域
      13  }}

说明

默认游戏运行手机屏幕大小为800×400，当运行在其他屏幕大小的手机上时，首先计算出视口的缩放比，然后再计算出视口的偏移量，再通过设置相机的pixelRect，这样才能在不同分辨率的手机上显示出正确的游戏区域。

（6）创建武器管理对象。创建一个空物体，重命名为“Weapon Manager”，使其成为“Weapon Camera”的子对象，并添加Audio Source组建，此对象用于对Player所持枪械的管理。继续在“Weapon Manager”下面创建空物体“Deagle”，将Assets下面的“Hands+Deagle.fgx”模型拖动到“Deagle”下面。其他几种枪械的创建也一样。图4-45所示为Player部分对象的树形图。

▲图4-45 Player对象树形图

（7）编写脚本控制角色视角。新建脚本“PlayerLook.cs”，此类主要用来控制角色的视角方向，即使角色能够上、下、左、右观看游戏场景。将其挂载到Player和HeadLook上面，脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/PlayerController目录下的PlayerLook.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class PlayerLook : MonoBehaviour {
      4   ......//此类省略了其他函数和变量等的声明，请读者自行查阅光盘
      5   public RotationAxes axes = RotationAxes.MouseX;             //鼠标滑动方向变量
      6   void Update () {
      7        //此方法省略了其他代码片段，请读者自行查阅光盘
      8        if(!(Application.platform == RuntimePlatform.Android  //当在PC上运行时
      9                      || Application.platform == RuntimePlatform.IPhonePlayer)) {
      10             inputX = Input.GetAxis("Mouse X");               //水平距离由鼠标获得
      11             inputY = Input.GetAxis("Mouse Y");               //垂直距离由鼠标获得
      12        }
      13        else {
      14             if(enableTouch) {                                //当启用触控时
      15                  for(int i=0;i<Input.touchCount;i++) {      //遍历触摸点
      16                        Touch touch = Input.GetTouch(i);     //得到第i个触摸点
      17                        if(touch.fingerId == touchIndex)     //若同一个触摸点
      18                              continue;                       //跳过
      19                        else {
      20                             inputX = Mathf.Clamp(touch.deltaPosition.x, -1, 1);
                                                                      //水平距离由手指获得
      21                        inputY = Mathf.Clamp(touch.deltaPosition.y, -1, 1);//垂直距离由手指获得
      22        }}}}
      23        if(axes == RotationAxes.MouseX) {                     //鼠标水平滑动时
      24             transform.Rotate(0, inputX * sensitivityY, 0);  //根据鼠标的滑动转动角色
      25        }
      26        else if(axes == RotationAxes.MouseY) {                //鼠标竖直滑动时
      27             rotationY += inputY * sensitivityY;              //得到绕Y轴转动的角度
      28             rotationY = Mathf.Clamp (rotationY, minY, maxY);//限制角度范围
      29             transform.localEulerAngles =
      30                  new Vector3(-rotationY, transform.localEulerAngles.y, 0);//为角色设定姿态
      31  }}}}

第8行～第22行用于确定当前游戏是运行在手机平台上还是PC上，如果在PC上，那么inputX和inputY由鼠标确定。如果在手机上运行，那么这两个则分别由手指在屏幕上移动的水平距离和垂直距离确定。

第23行～第30行根据用户的不同移动范围，动态改变摄像机的视野范围。当水平滑动时，转动摄像机以左右查看场景。当垂直滑动时，使摄像机绕x轴旋转以上下查看场景。在Player上设置“Axes”为MouseX，在“HeadLook”上，设置“Axes”为MouseY。

（8）为了模拟真实的Player走路效果，需要编写脚本让角色在行走过程中有轻微的抖动效果。新建脚本“WalkSway.cs”，挂载到“Main Camera”和“Weapon Manager”对象上，此脚本通过控制摄像机的localPosition来达到动态模拟Player走路晃动的效果。脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/PlayerController目录下的WalkSway.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class WalkSway : MonoBehaviour {
      4   ......//此脚本省略了其他变量和函数的声明，请读者自行查阅光盘
      5   void FixedUpdate () {
      6        //此处省略了此方法部分代码片段，请读者自行查阅光盘
      7        transform.localPosition =
      8             Vector3.Lerp(transform.localPosition,currentPosition,i);//使用线性插值平滑改变位置
      9   }}

说明

在FixedUpdate函数中，使用线性插值来平滑地改变Player的localPosition属性，使其达到一种来回晃动的效果。

（9）为了使Player在行走的过程中，产生断断续续不停走路的声音，为此笔者收集了五种稍微有点不同的脚步声音，通过编写脚本随机播放这几个声音，可以模拟一种非常真实的走路声音效果。新建脚本“PlayerStepSound.cs”，并挂载到Player上，脚本代码如下。

代码位置：见随书光盘中源代码/第04章/FPSGame/Assets/Scripts/PlayerController目录下的PlayerStepSound.cs。

      1   using UnityEngine;
      2   using System.Collections;
      3   public class PlayerStepSound : MonoBehaviour {
      4        public AudioClip[] walkSounds;                         //脚步声音数组
      5        public float walkStepLength = 0.4f;                    //走动时声音的播放时间
      6        public float runStepLength = 0.32f;                    //跑动时声音的播放时间
      7        public float crouchStepLength = 0.5f;                  //蹲下时声音的播放时间
      8        private CharacterController controller;                //角色控制器
      9        private PlayerController motor;                        //玩家控制器脚本
      10       private float lastStep = -10.0f;                       //声音持续时间
      11       private float stepLength;                              //当前脚步声音持续时间
      12       ......//此处省略了Awake方法的介绍，请读者自行查阅光盘
      13       void FixedUpdate () {
      14            if(motor.walking && motor.grounded && !motor.crouch) {//当角色走动且没有蹲下
      15                 PlayStepSound();                             //调用播放声音方法
      16                 stepLength = walkStepLength;                 //设置声音播放时间
      17            }
      18            if(motor.running && motor.grounded) {            //当角色正在跑步
      19                 PlayStepSound();                             //调用播放声音方法
        20                 stepLength = runStepLength;                  //设置声音播放时间
        21            }
        22            if(motor.walking && motor.crouch && motor.grounded) {     //当蹲下时候
        23                 PlayStepSound();                             //调用播放声音方法
        24                 stepLength = crouchStepLength;              //设置声音播放时间
        25       }}
        26       void PlayStepSound() {
        27       if(Time.time > stepLength + lastStep) {               //当游戏时间大于间隔时间
        28        if(CameraAdaption.sound) {                            //如果可播放声音
        29             audio.clip = walkSounds[Random.Range(0, walkSounds.Length)];//随机选择声音
        30             audio.Play();                                    //播放声音
        31        }
        32        lastStep = Time.time;                                 //记录上次播放时间
        33  }}}

第13行～第25行，FixedUpdate函数主要负责在不同的情况下，设置播放声音的长度不同。一般来说，人物在走路、跑步和蹲下的时候，其所产生的脚步的声音时长是不同的。

第26行～第33行，PlayStepSound函数用于播放声音，当时间间隔大于stepLength，即当前没有声音正在播放时，如果系统允许播放声音，则从给定的walkSounds数组中，随机选择一种声音进行播放，并记录上次的播放时间。

（10）为Player添加第一人称控制器。单击“Player”→“Component”→“Physics”→“Character Controller”。图4-46所示为Player Inspector窗口显示的Character Controller组件。然后单击“Assets”→“Import Package”→“Character Controller”，导入第一人称控制器资源包。

▲图4-46 为Player添加Character Controller

（11）在导入资源包后，需要用到此资源包下面的一个脚本“CharacterMotor.js”。在Project窗口中依次展开路径“Assets/Standard Assets/Character Controllers/Sources/Scripts/”，读者可看到CharacterMotor.js脚本，新建脚本“PlayerController.cs”，挂载到“Player”上。其脚本代码如下。