[Unity3D]Unity3D游戏开发之角色控制漫谈

http://blog.csdn.net/qinyuanpei/article/details/39050631

版权声明：本文为博主原创文章，未经博主允许不得转载，如需转载请先授权，转载请注明本文作者及出处，谢谢！

        各位朋友，大家好，我是秦元培，欢迎大家关注我的博客，我的博客地址blog.csdn.net/qinyuanpei。今天呢，我们来说说Unity3D中的角色控制，这篇文章并非关注于Unity3D中的某项具体内容，而是博主在经过大量的实践后所得的感悟。今天的文章从内容上可以分为2种模式、1个组件、1种模型，希望对大家学习Unity3D起到良好的推动作用。好了，下面我们就正式开始今天的文章吧。

 

        一、2种模式

       众所周知，角色控制有第一人称和第三人称两种情况，在RPG游戏中通常以第三人称的形式出现。而对于第三人称角色控制而言，通常有2种模式。

       第一种模式中，角色在Z轴方向向前或者向后移动、绕自身Y轴旋转。当角色旋转时，摄像机会根据角色旋转的角度旋转到对应的位置，使摄像机始终正对着角色的背面，这样玩家在控制角色的过程中，只能看到玩家的背面。当角色移动时，摄像机会保持与玩家间的一定距离，然后跟随角色进行移动。采用这种模式的代表游戏是《仙剑奇侠传四》，这种模式的优点是操作简单，依靠四个方向键就可以完成角色的控制。这种模式的缺点同样很明显，因为摄像机始终面向角色背面，所以玩家无法看到角色的正面。从这个角度上来说，这种模式不能称之为真正的3D，因为玩家的视角是锁死的。那么在Unity3D中如何实现这种模式的角色控制呢？我们只需要为Main Camera添加一个SmoothFollow脚本，这样我们就可以使摄像机始终面向玩家的背面。对于角色这部分，我们只需要完成Z轴方向上的前进与后退，Y轴方向上的旋转即可。这部分脚本我们将放在后面来讲，因为这里需要用到一个重要的组件。

       下面来介绍第二种模式，这种模式是现下网游中较为流行的模式，在这种模式下，玩家可以按照自身坐标系向着四个不同的方向移动，当玩家按下鼠标右键时，可以绕Y轴按照一定的角度旋转摄像机，在旋转的过程中，角色将旋转相应的角度。在移动的过程中，摄像机会保持与玩家间的一定距离，然后跟随角色进行移动。这种模式的代表作有《古剑奇谭》、《仙剑奇侠传五前传》等。这种模式的优点是玩家可以自由地对角色进行观察，是真正意义上的3D。可是它不是没有缺点啊，在控制角色的时候，玩家需要双手同时进行操作。这种模式在Unity3D中的实现同样需要SmoothFollow脚本，不过需要克服对旋转角度的追踪。此外，我们还需要一个相机控制的脚本，这样我们可以在360度地欣赏游戏中的美丽场景。同样地，脚本我们放在后面来讲。

 

       二、1个组件

       在Unity3D中有一个称为角色控制器(CharacterController)的组件,从这个名称，我们就可以知道它是一个用来控制角色的组件。虽然通过Transform的方式同样可以实现角色的控制，可是相比Transform的方式，角色控制器具备了更为优越的特性。具体地说，角色控制器允许开发者在受制于碰撞的情况下很容易的进行运动，而不用处理刚体。按照博主的理解就是角色控制器具备Rigidbody组件的部分属性，如果使用角色控制器就可以不用用Rigidbody组件了。事实上，角色控制器可以忽略场景中重力的影响，但是受制于碰撞。这句话怎么理解呢？博主举一个例子，比如我们需要使角色受制于碰撞的影响，所以我们可以为角色添加一个刚体(Rigidbody)，可是我们同时不希望当角色和场景中的静态物体碰撞时被撞飞，固然我们可以通过限制角色在碰撞过程中的角度和位置变化来实现这样的效果，可是事实上如果角色和场景中的物体发生了碰撞，其碰撞的结果通常是不受玩家控制的，尤其是角色启用重力因素后，对于碰撞结果的控制会显得更加艰难。那么角色控制器就是为了满足这样一个需求而产生的。具体地说，通过角色控制器我们可以实现这样的需求：

        1、重力控制 由于CharacterController不受场景的重力影响，所以，设计者可以自行添加重力因素。例如在CharacterController组件中有一个isGrounded的属性，该属性可以判断角色是否位于地面上。需要注意的是，CharacterController依赖于碰撞，即地面和角色都需要有碰撞体才可以，一个较为有效的方法是使用标准的碰撞体如Box、Sphere、Capsule来作为一个模型的父容器。具体地应用我们会在最后的脚本部分给出来。

         2、爬楼梯 CharacterController.stepOffset属性使得角色具备了爬楼梯的能力，它是一个以米为单位的角色控制器的台阶偏移量，表示角色在垂直方向上台阶的高度。试想我们如果使用Transform方式实现这样的效果，恐怕我们需要费一番周折了，好在CharacterController可以帮助我们轻松地实现这样的功能，让玩家在游戏世界里更为自由和充满乐趣。

         3、爬斜坡 和stepOffset属性类似，slopeLimit可以设置允许角色攀爬的最大角度。利用这一属性最为显著的实例是在起伏的地面上控制角色，如果我们使用Transform方式来移动角色，可能会出现角色从地面上穿过去这样的情况，显然CharacterController再次让我们的问题变得简单。

      关于更多CharacterController的特性大家可以自行查阅API文档，

      然而不过无可否认的是CharacterController让我们控制角色变得更为简单，这一点大家可以在具体的项目中得到较为深刻的体会。

 

      三、1种模型

       如果说角色控制器的出现让我们控制角色变得更为简单，那么下面要讲的Locomotion模型将会让我们控制动画变得更为简单，特别强调是在控制角色移动动画的时候。关于Locomotion系统，我们可以把它当做是一个预制的动画模板，它定义了角色具体的状态下应该采用什么样的动画，而这一切的载体就是Unity3D的Mecanim动画系统。或许我们对于Locomotion模型不甚了解，可是我们会在Unity3D官方的示例项目中找到它的身影。使用Locomotion模型需要导入相应的资源包，我们可以在Unity3D资源商店里下载一个名为Mecanim Locomotion System StartKit的资源包，这样我们就可以在项目中使用Locomotion模型了。从官方的介绍中博主得知该模型主要的用途是能够自动混合关键帧或捕捉动画的走和跑的循环并且调整腿部骨骼的运动来保证脚步能正确地落在地面上。这个模型能调整并改变动画的速率和曲线以任何速率、方向、曲率、步幅从一个简单平面到任何倾斜角度的地形。在英文中Locomotion是运动的意思，所以这是一个提供角色运动支持的东西。可是博主目前并没有发现它在适应不同地形方面的特性，所以这里我们实际上还是在说Mecamin动画系统。这里我们以该资源包里的示例项目来讲解Locomotion模型。如图，在Animator窗口中可以看到它是一个Mecanim动画：

        如果大家熟悉Mecanim的话，可以很清楚地看出来它关联了多种动画状态。或许在不同的项目中，大家设计的Mecamim动画可能会有所不同，不过它的实质是一样的。我们继续来看这个资源包为我们提供的东西，在Script文件夹下我们可以看到一个Locomotion的脚本，这个脚本是我们使用Locomotion模型的前提，打开脚本我们会发现，这是对Unity3D Mecanim API的一种封装。

[csharp] view plaincopy

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class Locomotion  
5. {  
6.     private Animator m_Animator = null;  
7.       
8.     private int m_SpeedId = 0;  
9.     private int m_AgularSpeedId = 0;  
10.     private int m_DirectionId = 0;  
11.   
12.     public float m_SpeedDampTime = 0.1f;  
13.     public float m_AnguarSpeedDampTime = 0.25f;  
14.     public float m_DirectionResponseTime = 0.2f;  
15.       
16.     public Locomotion(Animator animator)  
17.     {  
18.         m_Animator = animator;  
19.   
20.         m_SpeedId = Animator.StringToHash("Speed");  
21.         m_AgularSpeedId = Animator.StringToHash("AngularSpeed");  
22.         m_DirectionId = Animator.StringToHash("Direction");  
23.     }  
24.   
25.     public void Do(float speed, float direction)  
26.     {  
27.         AnimatorStateInfo state = m_Animator.GetCurrentAnimatorStateInfo(0);  
28.   
29.         bool inTransition = m_Animator.IsInTransition(0);  
30.         bool inIdle = state.IsName("Locomotion.Idle");  
31.         bool inTurn = state.IsName("Locomotion.TurnOnSpot") || state.IsName("Locomotion.PlantNTurnLeft") || state.IsName("Locomotion.PlantNTurnRight");  
32.         bool inWalkRun = state.IsName("Locomotion.WalkRun");  
33.   
34.         float speedDampTime = inIdle ? 0 : m_SpeedDampTime;  
35.         float angularSpeedDampTime = inWalkRun || inTransition ? m_AnguarSpeedDampTime : 0;  
36.         float directionDampTime = inTurn || inTransition ? 1000000 : 0;  
37.   
38.         float angularSpeed = direction / m_DirectionResponseTime;  
39.           
40.         m_Animator.SetFloat(m_SpeedId, speed, speedDampTime, Time.deltaTime);  
41.         m_Animator.SetFloat(m_AgularSpeedId, angularSpeed, angularSpeedDampTime, Time.deltaTime);  
42.         m_Animator.SetFloat(m_DirectionId, direction, directionDampTime, Time.deltaTime);  
43.     }     
44. }  

    如果我们需要对角色进行控制，只需要使用下面的代码：

[csharp] view plaincopy

1.  /// <summary>  
2. ///   
3. /// </summary>  
4.   
5. using UnityEngine;  
6. using System;  
7. using System.Collections;  
8.     
9. [RequireComponent(typeof(Animator))]    
10.   
11. //Name of class must be name of file as well  
12.   
13. public class LocomotionPlayer : MonoBehaviour {  
14.   
15.     protected Animator animator;  
16.   
17.     private float speed = 0;  
18.     private float direction = 0;  
19.     private Locomotion locomotion = null;  
20.   
21.     // Use this for initialization  
22.     void Start ()   
23.     {  
24.         animator = GetComponent<Animator>();  
25.         locomotion = new Locomotion(animator);  
26.     }  
27.       
28.     void Update ()   
29.     {  
30.         if (animator && Camera.main)  
31.         {  
32.             JoystickToEvents.Do(transform,Camera.main.transform, ref speed, ref direction);  
33.             locomotion.Do(speed * 6, direction * 180);  
34.         }         
35.     }  
36. }  

       我们发现此时我们的脚本变得简单了许多，因为大量的脚本被转移到了Locomotion脚本中。而这就是博主想为大家介绍的Locomotion模型，通过该模型我们可以更容易地控制角色，不过恕博主直言，在国内如果采用这种模型来做游戏的话，可能会不太适应我们自己的游戏。因为在《仙剑奇侠传五》中最初就是因为采用类似这种的自动视角，导致游戏最初的游戏体验并不是很完美。再者像《仙剑奇侠传》、《古剑奇谭》这类中国传统风格的游戏在美学设计上更倾向于好看而不是真实，所以直接采用这样的模型会有点困难。不过还是那句话，我们不能因为某些客观的因素就停止学习啊，好了，Locomotion就先说到这里吧，下面我们来重点讲解脚本。

    下面讲述如何使用角色控制器来控制角色，我们一起来看下面的脚本：

[csharp] view plaincopy

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class PlayerController : MonoBehaviour {  
5.       
6.     //移动速度  
7.     public float MoveSpeed=1.5F;  
8.     //奔跑速度  
9.     public float RunSpeed=4.5F;  
10.     //旋转速度  
11.     public float RotateSpeed=30;  
12.     //重力  
13.     public float Gravity=20;  
14.     //动画组件  
15.     private Animator mAnim;  
16.     //声音组件  
17.     private AudioSource mAudio;  
18.     //速度  
19.     private float mSpeed;  
20.     //移动方式,默认为Walk  
21.     public TransportType MoveType=TransportType.Walk;  
22.     //游戏管理器  
23.     private GameManager mManager;  
24.     //角色控制器  
25.     private CharacterController mController;  
26.       
27.   
28.     void Start ()   
29.     {  
30.        //获取动画组件  
31.        mAnim=GetComponentInChildren<Animator>();  
32.        //获取声音组件  
33.        mAudio=GetComponent<AudioSource>();  
34.        //获取游戏管理器  
35.        mManager=GameObject.Find("GameManager").GetComponent<GameManager>();  
36.        //获取角色控制器  
37.        mController=GetComponent<CharacterController>();  
38.     }  
39.   
40.     void Update ()   
41.     {  
42.         //只有处于正常状态时玩家可以行动  
43.         if(mManager.Manager_State==GameState.Normal)  
44.         {  
45.             MoveManager();  
46.         }  
47.     }  
48.       
49.     //移动管理  
50.     void MoveManager()  
51.     {  
52.         //移动方向  
53.         Vector3 mDir=Vector3.zero;  
54.         if(mController.isGrounded)  
55.         {  
56.            if(Input.GetAxis("Vertical")==1)  
57.            {  
58.               SetTransportType(MoveType);  
59.               mDir=Vector3.forward * RunSpeed * Time.deltaTime;  
60.            }  
61.            if(Input.GetAxis("Vertical")==-1)  
62.            {  
63.               SetTransportType(MoveType);  
64.               mDir=Vector3.forward * -RunSpeed * Time.deltaTime;  
65.            }  
66.            if(Input.GetAxis("Horizontal")==-1)  
67.            {  
68.               SetTransportType(MoveType);  
69.               Vector3 mTarget=new Vector3(0,-RotateSpeed* Time.deltaTime,0);  
70.               transform.Rotate(mTarget);  
71.            }  
72.            if(Input.GetAxis("Horizontal")==1)  
73.            {  
74.               SetTransportType(MoveType);  
75.               Vector3 mTarget=new Vector3(0,RotateSpeed* Time.deltaTime,0);  
76.               transform.Rotate(mTarget);  
77.            }  
78.            if(Input.GetAxis("Vertical")==0 && Input.GetAxis("Horizontal")==0)  
79.            {  
80.               mAnim.SetBool("Walk",false);  
81.               mAnim.SetBool("Run",false);  
82.            }  
83.        }  
84.         //考虑重力因素  
85.         mDir=transform.TransformDirection(mDir);  
86.         float y=mDir.y-Gravity *Time.deltaTime;  
87.         mDir=new Vector3(mDir.x,y,mDir.z);  
88.         mController.Move(mDir);  
89.   
90.        //使用Tab键切换移动方式  
91.        if(Input.GetKey(KeyCode.Tab))  
92.        {  
93.           if(MoveType==TransportType.Walk){  
94.             MoveType=TransportType.Run;  
95.           }else if(MoveType==TransportType.Run){  
96.             MoveType=TransportType.Walk;  
97.           }  
98.        }  
99.     }  
100.   
101.   
102.       
103.     //设置角色移动的方式  
104.     public void SetTransportType(TransportType MoveType)  
105.     {  
106.        switch(MoveType)  
107.        {  
108.             case TransportType.Walk:  
109.                 MoveType=TransportType.Walk;  
110.                 mAnim.SetBool("Walk",true);  
111.                 mSpeed=MoveSpeed;  
112.                 break;  
113.             case TransportType.Run:  
114.                 MoveType=TransportType.Run;  
115.                 mAnim.SetBool("Run",true);  
116.                 mSpeed=RunSpeed;  
117.                 break;  
118.        }  
119.     }  
120.   
121. }  

     以上这段脚本是博主在做的一个游戏中使用的代码，在这段脚本中你可以看到博主是如何利用CharacterController来控制角色的，即根据玩家的输入轴计算移动方向，如果玩家不在地面上(通过isGrounded属性来判断），则需要考虑重力因素，理论上角色从高处下落的时候应该是加速运动，根据物理学公式h=1/2gt^2，这里只是为了模拟重力，所以采用了简化的匀速运动，希望大家注意。这里还可以进一步扩展，比如我们所熟悉的经典射击游戏CS，玩家是可以跳跃的，那么利用角色控制器来实现这种效果该怎么做呢？很简单，这和模拟重力是一样的，即设定一个跳跃速度，如果玩家按下了空格键，则改变mDir中的y即可。这里我们使用的是第一种控制模式，即锁视角的控制模式，可能是因为博主最早接触的3D游戏是《仙剑奇侠传四》吧，所以博主更喜欢这样的控制模式。在这段脚本中有一个SetTransportType()的方法，用来切换角色移动的方式，主要是切换动画和移动速度。我知道很多朋友对不锁视角的控制模式可能更感兴趣，因为这是目前的主流，例如《新剑侠传奇》在宣传之初就以不锁视角、即时战斗作为主要的噱头，不过游戏发布后效果并没有预期的那样好，好在游戏制作方敢于承担错误，及时将游戏回炉重铸，足以看出制作方想做好游戏的诚意。不过，这种模式博主该没有研究出来，现在手上有了新模型，所以有时间的话博主会尝试这种新的模式，希望大家关注我的博客啊，博主会不定期地更新博客的。那么下面为大家分享一个从《UnityChan》找到的关于相机控制部分的脚本，可以实现对角色的自由观察。下面给出脚本：

[csharp] view plaincopy

1. //CameraController.cs for UnityChan  
2. //Original Script is here:  
3. //TAK-EMI / CameraController.cs  
4. //https://gist.github.com/TAK-EMI/d67a13b6f73bed32075d  
5. //https://twitter.com/TAK_EMI  
6. //  
7. //Revised by N.Kobayashi 2014/5/15   
8. //Change : To prevent rotation flips on XY plane, use Quaternion in cameraRotate()  
9. //Change : Add the instrustion window  
10. //Change : Add the operation for Mac  
11. //  
12.   
13.   
14.   
15.   
16. using UnityEngine;  
17. using System.Collections;  
18.   
19. namespace CameraController  
20. {  
21.     enum MouseButtonDown  
22.     {  
23.         MBD_LEFT = 0,  
24.         MBD_RIGHT,  
25.         MBD_MIDDLE,  
26.     };  
27.   
28.     public class CameraController : MonoBehaviour  
29.     {  
30.         [SerializeField]  
31.         private Vector3 focus = Vector3.zero;  
32.         [SerializeField]  
33.         private GameObject focusObj = null;  
34.   
35.         public bool showInstWindow = true;  
36.   
37.         private Vector3 oldPos;  
38.   
39.         void setupFocusObject(string name)  
40.         {  
41.             GameObject obj = this.focusObj = new GameObject(name);  
42.             obj.transform.position = this.focus;  
43.             obj.transform.LookAt(this.transform.position);  
44.   
45.             return;  
46.         }  
47.   
48.         void Start ()  
49.         {  
50.             if (this.focusObj == null)  
51.                 this.setupFocusObject("CameraFocusObject");  
52.   
53.             Transform trans = this.transform;  
54.             transform.parent = this.focusObj.transform;  
55.   
56.             trans.LookAt(this.focus);  
57.   
58.             return;  
59.         }  
60.       
61.         void Update ()  
62.         {  
63.             this.mouseEvent();  
64.   
65.             return;  
66.         }  
67.   
68.         //Show Instrustion Window  
69.         void OnGUI()  
70.         {  
71.             if(showInstWindow){  
72.                 GUI.Box(new Rect(Screen.width -210, Screen.height - 100, 200, 90), "Camera Operations");  
73.                 GUI.Label(new Rect(Screen.width -200, Screen.height - 80, 200, 30),"RMB / Alt+LMB: Tumble");  
74.                 GUI.Label(new Rect(Screen.width -200, Screen.height - 60, 200, 30),"MMB / Alt+Cmd+LMB: Track");  
75.                 GUI.Label(new Rect(Screen.width -200, Screen.height - 40, 200, 30),"Wheel / 2 Fingers Swipe: Dolly");  
76.             }  
77.   
78.         }  
79.   
80.         void mouseEvent()  
81.         {  
82.             float delta = Input.GetAxis("Mouse ScrollWheel");  
83.             if (delta != 0.0f)  
84.                 this.mouseWheelEvent(delta);  
85.   
86.             if (Input.GetMouseButtonDown((int)MouseButtonDown.MBD_LEFT) ||  
87.                 Input.GetMouseButtonDown((int)MouseButtonDown.MBD_MIDDLE) ||  
88.                 Input.GetMouseButtonDown((int)MouseButtonDown.MBD_RIGHT))  
89.                 this.oldPos = Input.mousePosition;  
90.   
91.             this.mouseDragEvent(Input.mousePosition);  
92.   
93.             return;  
94.         }  
95.   
96.         void mouseDragEvent(Vector3 mousePos)  
97.         {  
98.             Vector3 diff = mousePos - oldPos;  
99.   
100.             if(Input.GetMouseButton((int)MouseButtonDown.MBD_LEFT))  
101.             {  
102.                 //Operation for Mac : "Left Alt + Left Command + LMB Drag" is Track  
103.                 if(Input.GetKey(KeyCode.LeftAlt) && Input.GetKey(KeyCode.LeftCommand))  
104.                 {  
105.                     if (diff.magnitude > Vector3.kEpsilon)  
106.                         this.cameraTranslate(-diff / 100.0f);  
107.                 }  
108.                 //Operation for Mac : "Left Alt + LMB Drag" is Tumble  
109.                 else if (Input.GetKey(KeyCode.LeftAlt))  
110.                 {  
111.                     if (diff.magnitude > Vector3.kEpsilon)  
112.                         this.cameraRotate(new Vector3(diff.y, diff.x, 0.0f));  
113.                 }  
114.                 //Only "LMB Drag" is no action.  
115.             }  
116.             //Track  
117.             else if (Input.GetMouseButton((int)MouseButtonDown.MBD_MIDDLE))  
118.             {  
119.                 if (diff.magnitude > Vector3.kEpsilon)  
120.                     this.cameraTranslate(-diff / 100.0f);  
121.             }  
122.             //Tumble  
123.             else if (Input.GetMouseButton((int)MouseButtonDown.MBD_RIGHT))  
124.             {  
125.                 if (diff.magnitude > Vector3.kEpsilon)  
126.                     this.cameraRotate(new Vector3(diff.y, diff.x, 0.0f));  
127.             }  
128.                   
129.             this.oldPos = mousePos;   
130.   
131.             return;  
132.         }  
133.   
134.         //Dolly  
135.         public void mouseWheelEvent(float delta)  
136.         {  
137.             Vector3 focusToPosition = this.transform.position - this.focus;  
138.   
139.             Vector3 post = focusToPosition * (1.0f + delta);  
140.   
141.             if (post.magnitude > 0.01)  
142.                 this.transform.position = this.focus + post;  
143.   
144.             return;  
145.         }  
146.   
147.         void cameraTranslate(Vector3 vec)  
148.         {  
149.             Transform focusTrans = this.focusObj.transform;  
150.   
151.             vec.x *= -1;  
152.   
153.             focusTrans.Translate(Vector3.right * vec.x);  
154.             focusTrans.Translate(Vector3.up * vec.y);  
155.   
156.             this.focus = focusTrans.position;  
157.   
158.             return;  
159.         }  
160.   
161.         public void cameraRotate(Vector3 eulerAngle)  
162.         {  
163.             //Use Quaternion to prevent rotation flips on XY plane  
164.             Quaternion q = Quaternion.identity;  
165.    
166.             Transform focusTrans = this.focusObj.transform;  
167.             focusTrans.localEulerAngles = focusTrans.localEulerAngles + eulerAngle;  
168.   
169.             //Change this.transform.LookAt(this.focus) to q.SetLookRotation(this.focus)  
170.             q.SetLookRotation (this.focus) ;  
171.   
172.             return;  
173.         }  
174.     }  
175. }  

   下面是演示效果：

1、Locomotion演示

2、角色控制器演示(为节省容量只好牺牲质量啦.......)

好了，感谢大家关注我的博客，今天的内容就是这样了，希望大家喜欢。

每日箴言：当我真心在追寻着我的梦想时，每一天都是缤纷的，因为我知道每一个小时都是在实现梦想的一部分。—— 保罗·科埃略

   喜欢我的博客请记住我的名字：秦元培，我博客地址是blog.csdn.net/qinyuanpei。
   转载请注明出处，本文作者：秦元培，本文出处：http://blog.csdn.net/qinyuanpei/article/details/39050631