Unity3D游戏开发之跑酷游戏项目详解

        今天的博客的主题就是《游戏开发之跑酷游戏项目讲解》。

        从我们自身来考虑这件事情，当你选择做自己热爱的事情的时候，你的内心一定是充满激情和勇气的，你愿意看到自己的努力，你愿意看到自己的付出，我们成长是为了促进自我对认知的不断完善，所以我们应该以一种虔诚、谦恭的态度来对待我们的生命，我们或许无法选择出身，但我们可以选择向自己喜欢的生活去努力。或许我和这些人真的不是一个世界的人吧，很多事情在今天都给出了结局，对于这种人我已经没有再尝试与之交流的想法了，或许大学四年平平淡淡，留给我的只有自己才能体会的孤独吧。好了，不说我的事情了，我们正式开始今天的内容吧！

       一、游戏策划

     游戏采用2D界面，角色从左到右奔跑，在路段中随机生成障碍物和金币，玩家需要使用跳跃功能躲开障碍物，在游戏中玩家收集的金币数目越多，奔跑的距离越长，玩家的得分就越高。我们最终实现的界面效果如图所示，首先我们来讲一下游戏的原理，我们这里这里采用的方法是路段固定，移动摄像机的方法。换句话说，当角色开始移动后，摄像机和场景跟随角色缓缓向右移动。当角色跑完每一个路段距离的2/3时，计算下一路段的位置，并在该位置生成一个新的路段，这样在游戏场景中可以产生无限远的路段，当某一路段离开摄像机视野时，立即将其销毁。于此同时，我们在每一个路段上随机产生障碍物和金币，然后对角色做碰撞检测即可。

         二、角色控制

     角色控制这里，我们只关注角色的状态，即角色是处于奔跑状态还是死亡状态。通过这一状态，我们针对角色采取不同的处理方式。如果角色处于奔跑状态，则更新角色位置、摄像机位置、背景位置，否则角色将在被障碍物撞到以后倒地死亡。我们来一起看下面的脚本：

[csharp]  view plain copy print ?

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class Player : MonoBehaviour {  
5.   
6.     //定义角色移动速度  
7.     public float mMoveSpeed=2.5F;  
8.   
9.     //摄像机  
10.     private Transform mCamera;  
11.     //背景图片  
12.     private Transform mBackground;  
13.   
14.     //角色是否在奔跑  
15.     private bool isRuning=true;  
16.     //场景中路段总数目  
17.     private int mCount=1;  
18.   
19.     //路段预设  
20.     public GameObject CubeWay;  
21.   
22.     //死亡动画播放次数  
23.     private int DeathCount=0;  
24.   
25.     //收集的金币数目  
26.     private int mCoinCount=0;  
27.     public int CoinCount {  
28.         get {  
29.             return mCoinCount;  
30.         }  
31.     }  
32.   
33.     //当前奔跑距离  
34.     private int mLength=0;  
35.     public int Length {  
36.         get {  
37.             return mLength;  
38.         }  
39.     }  
40.   
41.     //当前得分  
42.     private int mGrade=0;  
43.     public int Grade {  
44.         get {  
45.             return mGrade;  
46.         }  
47.     }  
48.   
49.     void Start ()   
50.     {  
51.         //获取相机  
52.         mCamera=Camera.main.transform;  
53.         //获取背景  
54.         mBackground=GameObject.Find("Background").transform;  
55.     }  
56.   
57.     void Update ()   
58.     {  
59.         //如果角色处于奔跑状态则移动角色、相机和场景  
60.         if(isRuning)  
61.         {  
62.             Move();  
63.             CreateCubeWay();  
64.             Jump();  
65.             UpdateData();  
66.         }else  
67.         {  
68.             Death();  
69.         }  
70.     }  
71.   
72.     /// <summary>  
73.     /// 更新玩家的游戏数据  
74.     /// </summary>  
75.     private void UpdateData()  
76.     {  
77.         //计算奔跑距离  
78.         mLength=(int)((transform.position.x+25)*25);  
79.         //计算玩家得分  
80.         mGrade=(int)(mLength*0.8+mCoinCount*0.2);  
81.     }  
82.   
83.   
84.     ///角色死亡  
85.     private void Death()  
86.     {  
87.         //为避免死亡动画在每一帧都更新，使用DeathCount限制其执行  
88.         if(DeathCount<=1)  
89.         {  
90.            //播放死亡动画  
91.            transform.animation.Play("Lose");  
92.            //次数+1  
93.            DeathCount+=1;  
94.            //保存当前记录  
95.            //PlayerPrefs.SetInt("这里填入一个唯一的值",Grade);  
96.         }  
97.     }  
98.   
99.     private void Jump()  
100.     {  
101.         //这里不能使用刚体结构，所以使用手动方法实现跳跃  
102.         if(Input.GetKeyDown(KeyCode.Space) || Input.GetMouseButton(0))  
103.         {  
104.             while(transform.position.y<=1)  
105.             {  
106.                 float y=transform.position.y+0.02F;  
107.                 transform.position=new Vector3(transform.position.x,y,transform.position.z);  
108.                 transform.animation.Play("Jump");  
109.             }  
110.             StartCoroutine("Wait");  
111.         }  
112.     }  
113.   
114.     IEnumerator Wait()  
115.     {  
116.         yield return new WaitForSeconds(0.8F);  
117.         //角色落地继续奔跑  
118.         while(transform.position.y>0.125F)  
119.         {  
120.             float y=transform.position.y-0.02F;  
121.             transform.position=new Vector3(transform.position.x,y,transform.position.z);  
122.             transform.animation.Play("Run");  
123.         }  
124.     }  
125.   
126.     //移动角色、相机和场景  
127.     private void Move()  
128.     {  
129.         //让角色从左到右开始奔跑  
130.         transform.Translate(Vector3.forward * mMoveSpeed * Time.deltaTime);  
131.         //移动摄像机  
132.         mCamera.Translate(Vector3.right * mMoveSpeed * Time.deltaTime);  
133.         //移动背景  
134.         mBackground.Translate(Vector3.left * mMoveSpeed * Time.deltaTime);  
135.     }  
136.   
137.     //创建新的路段  
138.     private void CreateCubeWay()  
139.     {  
140.         //当角色跑完一个路段的的2/3时，创建新的路段  
141.         //用角色跑过的总距离计算前面n-1个路段的距离即为在第n个路段上跑过的距离  
142.         if(transform.position.x+30-(mCount-1)*50 >=50*2/3)  
143.         {  
144.             //克隆路段  
145.             //这里从第一个路段的位置开始计算新路段的距离  
146.             GameObject mObject=(GameObject)Instantiate(CubeWay,new Vector3(-5F+mCount * 50F,0F,-2F),Quaternion.identity);  
147.             mObject.transform.localScale=new Vector3(50F,0.25F,1F);  
148.             //路段数加1  
149.             mCount+=1;  
150.         }  
151.     }  
152.   
153.     void OnTriggerEnter(Collider mCollider)  
154.     {  
155.         //如果碰到的是金币，则金币消失，金币数目加1;  
156.         if(mCollider.gameObject.tag=="Coin")  
157.         {  
158.             Destroy(mCollider.gameObject);  
159.             mCoinCount+=1;  
160.         }  
161.         //如果碰到的是障碍物，则游戏结束  
162.         else if(mCollider.gameObject.tag=="Rock")  
163.         {  
164.             isRuning=false;  
165.         }  
166.     }  
167. }  

      在这里我们需要关注下面的内容：

      1、Update()方法及Move()、Jump()、CreateCubeWay()、Death()方法，因为这是角色在奔跑过程中的核心控制方法。

      2、CreateCubeWay()方法的作用是在玩家跑完每一个路段的2/3时，在指定的位置生成新的路段。假设当前场景中共有n个路段，玩家在每一个路段上奔跑的距离=用玩家从起点到当前位置的长度-前面n-1个路段的距离。通过这种方法我们可以判断玩家在每一个路段上的相对位置。在确定了这个位置后，我们将其与路段长度的2/3比较，如果大于或者等于这个距离，则生成新的路段，且第n+1个路段的位置等于第一个路段的位置+n个路段的总长度。由此，我们就实现了在指定的位置生成新的路段，使场景中源源不断的生成新的路段。

     3、玩家收集金币和障碍物的碰撞检测都是在OnTrigger方法中实现的，我们使用了一个bool类型的标识变量isRuning来表示角色的状态，此状态直接影响Update()方法的执行，大家可以从代码中自己去寻找。

     4、这里角色的跳跃是通过脚本模拟出来的，因为这里使用刚体似乎不能实现博主想实现的那种效果，大家可以参考Jump()方法。

     三、场景布设

    这里我们2D平面作为游戏的背景，使用NGUI来显示界面文字内容。在场景中使用NGUI需要相机和Anchor设置为同一层级，并设置相机的景深，这样两个相机系统都能工作了。路段CubeWay是一个预设体Cube，负责在CubeWay上生成金币和障碍物，该对象关联在Player脚本上。玩家角色是一个3D的人物模型，最终场景布设效果如图所示：

    四、预设定义

   在这个游戏中需要重用的对象有路段CubeWay、金币Coin、障碍物Rock，我们分别来看他们的脚本：

[csharp]  view plain copy print ?

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class CubeWay : MonoBehaviour {  
5.   
6.     //在道路上显示的金币、障碍物  
7.     public GameObject[] mObjects;  
8.   
9.   
10.     void Start ()   
11.     {  
12.   
13.        //在每段路段上随机产生20到50个物品  
14.        int mCount=Random.Range(20,50);  
15.        for(int i=0;i<mCount;i++)  
16.        {  
17.           Instantiate(mObjects[0],new Vector3(Random.Range(this.transform.position.x-25,this.transform.position.x+25),1F,-2F),  
18.                         Quaternion.Euler(new Vector3(90F,180F,0F)));  
19.        }  
20.        //在每段路段上随机产生5到10个障碍物  
21.        mCount=Random.Range(5,10);  
22.        for(int i=0;i<mCount;i++)  
23.        {  
24.           Instantiate(mObjects[1],new Vector3(Random.Range(this.transform.position.x-25,this.transform.position.x+25),0.5F,-2F),  
25.                         Quaternion.Euler(new Vector3(90F,180F,0F)));  
26.        }  
27.     }  
28.   
29.     //当离开摄像机视野时立即销毁  
30.     void OnBecameInvisible()  
31.     {  
32.         Destroy(this.gameObject);  
33.     }  
34.   
35. }  

[csharp]  view plain copy print ?

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class Coin : MonoBehaviour {  
5.   
6.     //这里是一个控制金币旋转的脚本  
7.   
8.     void Update ()   
9.     {  
10.         transform.Rotate(Vector3.forward * 50F * Time.deltaTime);  
11.     }  
12.   
13.     //当离开摄像机视野时立即销毁  
14.     void OnBecameInvisible()  
15.     {  
16.         Destroy(this.gameObject);  
17.     }  
18. }  

[csharp]  view plain copy print ?

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class Rock : MonoBehaviour {  
5.   
6.     //当离开摄像机视野时立即销毁  
7.     void OnBecameInvisible()  
8.     {  
9.         Destroy(this.gameObject);  
10.     }  
11. }  

     其中CubeWay就是一个Cube、Coin是一个圆柱体，为了让金币看起来好看点，我们让金币在空中旋转起来、Rock就是一个平面贴图。这里Rock、Coin将绑定到CubeWay的mObjects。

    

    五、游戏管理

   最后是界面的数据更新啦，脚本定义如下：

[csharp]  view plain copy print ?

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class GameManager : MonoBehaviour {  
5.   
6.     //游戏界面根节点  
7.     private Transform GameUI;  
8.     //玩家  
9.     private Transform mPlayer;  
10.     //界面金币数及距离  
11.     private Transform mCoins;  
12.     private Transform mLength;  
13.   
14.     void Start ()   
15.     {  
16.         GameUI=GameObject.Find("2DUI").transform;  
17.         mPlayer=GameObject.Find("People").transform;  
18.         mCoins=GameUI.FindChild("Anchor/Panel/Coins").transform;  
19.         mLength=GameUI.FindChild("Anchor/Panel/Length").transform;  
20.     }  
21.   
22.     void Update ()   
23.     {  
24.         mCoins.GetComponent<UILabel>().text="金币:" + mPlayer.GetComponent<Player>().CoinCount;  
25.         mLength.GetComponent<UILabel>().text="距离:" + mPlayer.GetComponent<Player>().Length;  
26.     }  
27. }  

     好了，到现在整个游戏已经讲解完了，相信大家已经迫不及待地想看看最终的效果了，好，我们一起来看看吧：

         希望今天的内容大家能够喜欢，希望大家继续支持和关注我的博客，如果我们对今天的例子稍作修改，就可以实现3D版的跑酷，经典的《神庙逃亡》游戏就是基于游戏引擎开发的。