2013-11-20 20:12:45 huangfe1 阅读数 862
  • Unity3D实战入门之人称射击游戏(TPS)

    这是一套第三人称射击游戏开发的入门基础课程。 本课程以一款小型的第三人称射击游戏为案例,手把手教你如何搭建一款3D射击游戏的雏形。麻雀虽小,五脏俱全,这款小游戏难度不大,但第三人称射击游戏该有的模块、功能它都有涉及。通过案例游戏的开发,学习者可以对第三人称射击游戏入门,对后续复杂大中型3D游戏的开发有实际的借鉴意义。 这套课程,对初次接触3D射击类游戏的学习者而言,是一块极好的跳板。

    1824 人正在学习 去看看 伍晓波



那抱歉,上次那个Unity+kinect还没有更新,最近在深一步研究,不久将更新(绝对不负众望)!现在进入正题,十分钟带你打造unity3D第一人称射击游戏!

看完本篇博客,你将学会第一人称控制,粒子的添加,碰撞的检测,鼠标的监听,画2d图像,预制物体克隆,添加力,添加声音等等!(本篇博客假设你已经对unity稍微有点了解)

一,打开unity,创建一个场景,添加一个plane,(gameobject->createother->plane)。

二,添加虚拟第一人称任务(现在没搞模型,模型后面可以自己添加);Assert->importpackages->Charactercontroll,之后你将Project面板里面看到这个资源包,打开里面的charactercontroll文件,将里面的first Person controll拖动到合适的位置。

三,然后我们将添加一个虚拟的枪口,作为子弹的发生点!这个你可以创建一个椭圆,放在摄像机的最中间


 然后要将椭圆设置为摄像机的子物体,这样他将随着摄像机运动(不能设置为任务模型的子物体,因为任务模型的不能上下移动,也就不是这样后不能上下射击)。也就是在hierahcry面板中点击你创建椭圆,拖到摄像机上,这样他就成了摄像机的子物体。可以点击运行测试下,你会发现这东西只是虚拟枪口,所以我们设置它看不见,点击椭圆,在修改面板上,有个MeshRender,你单击下,椭圆就看不见了,但是它存在,然后再点击CapsuleColisder,取消他的碰撞(以免影响子弹的射击);
三,子弹的射击

我们首先创建一个圆,(用这个圆来模拟子弹,如果你自己有子弹模型,就用子弹模型),然后在project中创建一个prefab,用于之后的克隆子弹,现在我们来子弹一点火焰效果,Assert->importpackage->particles导入粒子,点击里面的fire,将里面的Flame拖到游戏中,位置和你创建的球(子弹)一样,然后将你设置的,然后同样的方法,将火焰设置为,子弹的子物体,这样,火焰将和子弹一起运动,自己在属性面板里 修改火焰的大小,然后将子弹拖到你创建的prefab中,修改prefab的名字为balls!添加一个刚体属性,Rigidbody(Addcomment->ragidbody)然后删除游戏中的子弹(嗯,删除)!现在子弹的预制物体已经创建好了,现在我们来射击!

四 ,点击鼠标,发生子弹

现在 就是敲代码码的时候了

var aim:Transform;
//克隆子弹
private var ball:Transform;
//绘制准星的材质
var material:Material;
function Start () {

}

function Update () {
//将鼠标的图标隐藏
Screen.showCursor=false;
//var zj=Vector3(Screen.width/2,Screen.height/2,0);
//var ray:Ray=Camera.main.ScreenPointToRay(Input.mousePosition);
//定义一个方向,为发射点y轴方向
var dir=aim.transform.TransformDirection(Vector3.up);
//var dir=ray.direction;
//按下鼠标左键
if(Input.GetMouseButtonDown(0)){
//实列化一个球,发射点的位置,
ball=Instantiate(balls,aim.position,Quaternion.identity);
//在某一个方向加一个力
ball.rigidbody.AddForce(dir.normalized*1000);
print("----------->>>");
//三秒后删除小球
Destroy(ball.gameObject,3);
}
}

 这里用到了,Screen.showCursor=false;将鼠标隐藏,要将他放在updatae中,放在start中不行var dir=aim.transform.TransformDirection(Vector3.up);这是定义一个方向,子弹将以这个方向射击

其他的没什么解释的了,注释很详细了,方法里面传入的参数,查一下API文档就行

五 ,现在们开始绘制准星

 

//绘制准星的材质

var material:Material;

先定义 一个材质,用来绘制图像

 

//绘制准星
function OnPostRender(){
DrawRecent(Screen.width/2,Screen.height/2,10,10);
}
//绘制四边形的方法
function DrawRecent(x:float,y:float,width:float,height:float){
//材质通道设置为默认的0
 material.SetPass(0);
 //绘制2D图形
  GL.LoadOrtho();
 //绘制长方体
 GL.Begin(GL.QUADS);
 //传入四个点的相对屏幕的坐标,先后分别是左上角,左下角,右下角,右上角
  GL.Vertex(new Vector3(x/Screen.width,y/Screen.height,0));
  GL.Vertex(new Vector3(x/Screen.width,(y+height)/Screen.height,0));
  GL.Vertex(new Vector3((x+width)/Screen.width,(y+height)/Screen.height,0));
  GL.Vertex(new Vector3((x+width)/Screen.width,y/Screen.height,0));
  //结束绘画
  GL.End();
}

 这个没什么好解释的,注释有,按照各个规则就是

 

然后就是,如果你射击到了敌人,敌人就着火

四,射击敌人

首先我们,创建几个cube,这个用来模拟敌人,如果你有好的模型,就用模型。给cube创建ridibody

然后给它一个标签,在属性面板上面有个Tag,点击,选择player,给个player标签,你也可以点击addTag自己添加一个Tag,现在我们创建一个prefab预制火火焰,创建一个空物体,将先前导入的fires拖到空物体中

将空物体放入prefab中,改名为fires

现在 我们添加碰撞事件

新建一个脚本,

 

#pragma strict
//预制火焰
var fires:Transform;
//克隆火焰
private var fire:Transform;
function Start () {

}

function Update () {

}//碰撞监听
function OnCollisionEnter(other:Collision){
//如果碰到的事cube(先前我们将cube的tag设置成了player)
if(other.transform.tag=="Player"){
//克隆一个火焰
fire=Instantiate(fires,other.transform.position,Quaternion.identity);
//设置火焰的父对象为箱子,这样火焰将和物体一起运动,
fire.transform.parent=other.transform;}
}

 五,你想加入声音嘛?如果你想,接着看两种方式添加音乐,首先添加背景音乐,点击摄像机,AddCommpent->aduio->aduiosource

 

首先 下载你需要的背景音乐,将音乐拖进Asset文件夹中,然后将音乐拖进刚才添加的aduiosource的中

然后 教你添加动作音效,在第一和代码中加入var music:AudioClip;

然后再发生子弹的那个方法中,AudioSource.PlayClipAtPoint(music,transform.position);播放,

六:挂载脚本

你首先将以第一个脚本,挂到摄像机上面,然后将第一个frefab(balls)拖到变量中

第二个脚本放在balls上,将fires和音乐拖到变量中!!

OK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 现在开火!!!!!!!!!

 

 

 

源码下载

2011-10-23 14:25:37 ys496332598 阅读数 2352
  • Unity3D实战入门之人称射击游戏(TPS)

    这是一套第三人称射击游戏开发的入门基础课程。 本课程以一款小型的第三人称射击游戏为案例,手把手教你如何搭建一款3D射击游戏的雏形。麻雀虽小,五脏俱全,这款小游戏难度不大,但第三人称射击游戏该有的模块、功能它都有涉及。通过案例游戏的开发,学习者可以对第三人称射击游戏入门,对后续复杂大中型3D游戏的开发有实际的借鉴意义。 这套课程,对初次接触3D射击类游戏的学习者而言,是一块极好的跳板。

    1824 人正在学习 去看看 伍晓波



<pre name="code" class="csharp">using UnityEngine;
using System.Collections;

public class TP_Camera : MonoBehaviour
{
 
   publicstatic TP_Camera Instance;
    
    publicTransform TargetLookAt;
    public float Distance = 15f;
    public float DistanceMin = 3f;
    public int DistanceMax = 50;
    public floa tDistanceSmooth = 0.05f;
    public float X_MouseSensitivity = 5f;
    public float Y_MouseSensitivity = 5f;
    public float MouseWheelSensitivity = 5f;
    public float Y_MinLimit  = -40f;
    public float Y_MaxLimit = 80f;
    public float X_Smooth = 0.05f;
    public float Y_Smooth = 0.1f;
    
    private float mouseX = 0f;
    private float mouseY = 0f;
    private float velY = 0f;
    private float velX = 0f;
    private float velZ = 0f;
    private Vector3 position = Vector3.zero;
    private float velDistance = 0f;
    private float startDistance = 0f;
    private Vector3 desiredPosition = Vector3.zero;
    private float desiredDistance = 0f;
    
    
    void Awake()
    {
      Instance = this;
      
    }
    
    void Start()
    {
      Distance =Mathf.Clamp(Distance,DistanceMin,DistanceMax);      //Clamps a value between a minimum float andmaximum float value.   
      startDistance =Distance;   
      Reset();
      
    }
    
    void LateUpdate()
    {
      if(TargetLookAt == null)
         return;
      
      HandlePlayerInput();
      
      CalculateDesiredPosition();
      
      CheckCameraPoints(TargetLookAt.position,desiredPosition);
      
      UpdatePosition();
      
    }
    
    void HandlePlayerInput()
    {
      var deadZone = 0.1f;
      
      if(Input.GetMouseButton(1))   //values are 0 for left button, 1 for rightbutton, 2 for the middle button.
      {
         mouseX += Input.GetAxis("Mouse X") *X_MouseSensitivity;      //// Get the mouse delta. This is not in therange -1...1

         mouseY -= Input.GetAxis("Mouse Y") *Y_MouseSensitivity;
      }
    //This iswhere we will limit mouseY
    mouseY =Helper.ClampAngle(mouseY, Y_MinLimit,Y_MaxLimit);
    
   if(Input.GetAxis("Mouse ScrollWheel")< -deadZone || Input.GetAxis("Mouse ScrollWheel")> deadZone)
    {
      desiredDistance = Mathf.Clamp(Distance -Input.GetAxis("Mouse ScrollWheel") *MouseWheelSensitivity,DistanceMin,DistanceMax);
      
    }
}
    void CalculateDesiredPosition()
    {
      //Evaluate distance
      Distance = Mathf.SmoothDamp(Distance,desiredDistance, ref velDistance,DistanceSmooth);
      
      //Calculate desired position
      desiredPosition = CalculatePosition(mouseY,mouseX, Distance);
         
    }
    
    Vector3 CalculatePosition(float rotationX,float rotationY,floatdistance)
    {
      Vector3 direction  = newVector3(0,0, -distance);
      Quaternion rotation =Quaternion.Euler(rotationX,rotationY,0);
      return TargetLookAt.position + rotation *direction;
      
    }
    
    float CheckCameraPoints(Vector3 from,Vector3 to)
    {
      var nearDistance = -1f;
      
      RaycastHit hitInfo;
      
      Helper.ClipPlanePoints clipPlanePoints =Helper.ClipPlaneAtNear(to);
      
      //Draw lines in the editor to make it easier tovisulize
      Debug.DrawLine(from,to + transform.forward *-camera.nearClipPlane,Color.red);
      Debug.DrawLine(from,clipPlanePoints.UpperLeft);
      Debug.DrawLine(from,clipPlanePoints.LowerLeft);
      Debug.DrawLine(from,clipPlanePoints.UpperRight);
      Debug.DrawLine(from,clipPlanePoints.LowerLeft);
      
      Debug.DrawLine(clipPlanePoints.UpperLeft,clipPlanePoints.UpperRight);
      Debug.DrawLine(clipPlanePoints.UpperRight,clipPlanePoints.LowerRight);
      Debug.DrawLine(clipPlanePoints.LowerRight,clipPlanePoints.LowerLeft);
      Debug.DrawLine(clipPlanePoints.LowerLeft,clipPlanePoints.UpperLeft);
      
      return nearDistance;
    }
      
    void UpdatePosition()
    {
      var posX = Mathf.SmoothDamp(position.x,desiredPosition.x ,ref velX,X_Smooth);
      var posY = Mathf.SmoothDamp(position.y,desiredPosition.y ,ref velY,Y_Smooth);
      var posZ = Mathf.SmoothDamp(position.z,desiredPosition.z ,ref velZ, X_Smooth);
      position = new Vector3(posX,posY,posZ);
      
      transform.position = position;
      
      transform.LookAt(TargetLookAt);
      
    }
    
    public void Reset()
    {
      mouseX = 0;
      mouseY = 10;
      Distance = startDistance;
      desiredDistance = Distance;
    }
    
    public static void UseExistingOrCreateMainCamera()
    {
      GameObject tempCamera;
      GameObject targetLookAt;
      TP_Camera myCamera;
      
      if(Camera.main != null)
      {
         tempCamera = Camera.main.gameObject;
      }
      else
      {
         tempCamera = new GameObject("Main Camera");
         tempCamera.AddComponent("Camera");
         tempCamera.tag = "MainCamera";
      
      
      tempCamera.AddComponent("TP_Camera");
      }
      myCamera = tempCamera.GetComponent("TP_Camera")as TP_Camera;
      
      targetLookAt = GameObject.Find("targetLookAt") asGameObject;
      
      if(targetLookAt == null)
      {
         
         targetLookAt = newGameObject("targetLookAt");
         targetLookAt.transform.position =Vector3.zero;
      }
      
      myCamera.TargetLookAt =targetLookAt.transform;
    }
}





2014-01-14 23:56:33 s10141303 阅读数 33589
  • Unity3D实战入门之人称射击游戏(TPS)

    这是一套第三人称射击游戏开发的入门基础课程。 本课程以一款小型的第三人称射击游戏为案例,手把手教你如何搭建一款3D射击游戏的雏形。麻雀虽小,五脏俱全,这款小游戏难度不大,但第三人称射击游戏该有的模块、功能它都有涉及。通过案例游戏的开发,学习者可以对第三人称射击游戏入门,对后续复杂大中型3D游戏的开发有实际的借鉴意义。 这套课程,对初次接触3D射击类游戏的学习者而言,是一块极好的跳板。

    1824 人正在学习 去看看 伍晓波

最近一直在搞3D漫游,在第一人称和第三人称视角切换碰到些问题,视角的例子我是导入的官方的character controller包,不得不佩服官方脚本语言的写法,看了一下写的很完美,新手估计比较难看懂,里面涉及到一些角度,还有向量等的计算,这就要求有一定的图形学的基础,我将官方的第一人称视角和第三人称视角结合了一下,但发现还是不那么容易,不仅仅只是简单的摄像机的切换和position以及rotation的赋值而已,当然这种方法适合第三人称切换至第一人称,而第一人称切换至第三人称你会发现根本方向就切换不过来,位置是对了,但方向还是原来的方向,这就让我有点苦恼,然后不得已只能硬着头皮去看官方写的控制第三人称人物运行的脚本ThirdPersonController,里面有一些英文的注解,这脚本写的还是有一定的技术含量,毕竟是官方的嘛,想要看懂还是要慢慢静下心来看的。

 

无意中发现了一个巨牛巨牛的人工智能教程,忍不住分享一下给大家。教程不仅是零基础,通俗易懂,小白也能学,而且非常风趣幽默,还时不时有内涵段子,像看小说一样,哈哈~我正在学习中,觉得太牛了,所以分享给大家。点这里可以跳转到教程!

 

更多精品教程:

http://dingxiaowei.cn

实现步骤:                                                                                                                                                                                                        

1.导入官方的第一人称和第三人称的Person,会发现,第三人称的Main Camera是在model的外面而第一人称的Main Camera是在model的里面,这里最好统一一下,我将第三人称的那个model拉到我新建的一个空物体下(记得reset这空物体),然后将主摄像机也拖放到这个空物体下,最好确保camera和3rdPersonController平级。这里还要说一下的,将3rdPersonController也reset一下,然后设置PositionY跟相机的Y一样,我这里设置的是51大概。

 

2.创建视角切换的脚本viewpointSwitch,挂在GUI的物体上,这个物体挂了一些关于GUI还有控制鼠标隐藏显示的脚本

鼠标隐藏和显示:

void Update() 
{
	 if (Input.GetKey(KeyCode.H))
	// Lock the cursor inside gameview
	 Screen.lockCursor = true;
	// Hide mouse cursor
	Screen.showCursor = false;
	
	if(Input.GetKey(KeyCode.U))
	 // Lock the cursor inside gameview
	Screen.lockCursor = false;
	//Show mouse cursor
	Screen.showCursor = true;
}


viewpointSwitch:

using UnityEngine;
using System.Collections;

public class ViewpointSwitch : MonoBehaviour {
    //从场景中拖入的object
    public GameObject Obj_3rd;
    public GameObject cam_3rd;
    public GameObject gobj_3rd;

    public GameObject Obj_1fs;
    public GameObject cam_1fs;
    public GameObject gobj_1fs;

    //记录刚进入第一人称视角时候的欧拉角和离开第一视角时候的欧拉角(Y方向)
    float pre1fsAngle = 0;
    float cur1fsAngle = 0;

	// Update is called once per frame
	void Update ()
    {
        //切换至第一人称视角
        if (Input.GetKey(KeyCode.F1))
        {
            //记录一开始
            //pre1fsAngle = cam_1fs.transform.eulerAngles.y;
            pre1fsAngle = cam_3rd.transform.eulerAngles.y;  //记录的第一人称(这里取的是第三人称,其实是一样的)一开始的y方向欧拉角,这里没用上面注释掉的写法是防止重复按f1键切换然后覆盖初始值导致旋转角度差值缩小
            if (!Obj_1fs.activeSelf)
            {
                Obj_1fs.SetActive(true);
                GameObject.Find("Main Character Controller").transform.localPosition = GameObject.Find("3rd Person Controller").transform.localPosition;
                GameObject.Find("Main Character Controller").transform.localRotation = GameObject.Find("3rd Person Controller").transform.localRotation;
                Obj_3rd.SetActive(false);
            }
        }
        //切换至第三人称视角
        if (Input.GetKey(KeyCode.F2))
        {
            cur1fsAngle = cam_1fs.transform.eulerAngles.y;  //记录
            if (!Obj_3rd.activeSelf)
            {
                Obj_3rd.SetActive(true);
                GameObject.Find("3rd Person Controller").transform.localPosition = GameObject.Find("Main Character Controller").transform.localPosition;
                //注意这里Mathf里面的方法是幅度,我这里就进行了一个角度转幅度的计算:幅度=角度*pi/180
                float angle = (cur1fsAngle - pre1fsAngle) * Mathf.PI / 180;
                gobj_3rd.GetComponent<ThirdPersonController>().v = Mathf.Cos(angle);
                gobj_3rd.GetComponent<ThirdPersonController>().h = Mathf.Sin(angle);
                print("旋转角度:" + (cur1fsAngle-pre1fsAngle));
                gobj_3rd.GetComponent<ThirdPersonController>().flag = true;  //这个flag标志是让ThirdPersonController的update方法执行改变上面的v,h一次,然后第二帧的时候就执行v=Input.GetAxisRaw("Vertical")和h=Input.GetAxisRaw("Horizontal")
                Obj_1fs.SetActive(false);
            }
        }
	}
}

备注:
//w(1) & s(-1)(前后运动)
v = Input.GetAxisRaw("Vertical");

 //a(-1) & d(1)(左右运动)

 h = Input.GetAxisRaw("Horizontal");

这里的v和h变量要解释一下,v代表前后方向,如果按下前方向w键,这里Input.GetAxisRaw("Vertical")会有一个-1~1的一个变化,如果是遥感就会有浮点数,但如果是键盘的话,一般就是0,-1,1三个状态,按下w前进方向键,v会变成1,如果按下后退键s,v就会变成-1,如果不按则是0。h就是代表水平左右轴向,a键按下h=-1,d按下h=1,不按则代表0。

ThirdPersonController.js人物旋转的方向是始终转向一个前进的方向向量,var targetDirection = h * right + v * forward;

这里的right和forward分表表示X轴(forward方向)和Z轴(right方向)的单位向量

var forward = cameraTransform.TransformDirection(Vector3.forward);

var right = Vector3(forward.z, 0, -forward.x);

 

效果图:                                                                                                                                                                                                              

1.刚开始启动,第三人称的模型朝向以及旋转坐标

    

2.按一下D键,也就是右键,人物旋转,90度,朝向以及旋转坐标,以及v,h(控制旋转方向的一个系数,上文有介绍)的值

 

 

在线展示:                                                                                                                  

http://ueige123.oicp.net/dingxiaowei/13viewpointswitch/13viewpointswitch.html

 

 

==================== 迂者 丁小未 CSDN博客专栏=================

MyBlog:http://blog.csdn.net/dingxiaowei2013             MyQQ:1213250243

Unity QQ群:375151422         cocos2dx QQ群:280818155

====================== 相互学习,共同进步 ===================

 

转载请注明出处:http://blog.csdn.net/dingxiaowei2013/article/details/18281261

欢迎关注我的微博:http://weibo.com/u/2590571922

 

 

2015-02-15 13:30:37 book_longssl 阅读数 3796
  • Unity3D实战入门之人称射击游戏(TPS)

    这是一套第三人称射击游戏开发的入门基础课程。 本课程以一款小型的第三人称射击游戏为案例,手把手教你如何搭建一款3D射击游戏的雏形。麻雀虽小,五脏俱全,这款小游戏难度不大,但第三人称射击游戏该有的模块、功能它都有涉及。通过案例游戏的开发,学习者可以对第三人称射击游戏入门,对后续复杂大中型3D游戏的开发有实际的借鉴意义。 这套课程,对初次接触3D射击类游戏的学习者而言,是一块极好的跳板。

    1824 人正在学习 去看看 伍晓波


<P> using UnityEngine;   
using System.Collections;   </P>
<P>/**   
*  @Author : <A href="http://www.xuanyusong.com">www.xuanyusong.com</A>   
*/</P>
<P>[RequireComponent(typeof(CharacterController))]   
[AddComponentMenu("Character/Character Motor")]   </P>
<P>public class CharacterMotor : MonoBehaviour {   
   
    // Does this script currently respond to input?   
    public bool canControl  = true;   
   
    public bool useFixedUpdate = true;   
   
    // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.   
    // Very handy for organization!   
   
    // The current global direction we want the character to move in.   
    [System.NonSerialized]   
    public Vector3 inputMoveDirection = Vector3.zero;   
   
    // Is the jump button held down? We use this interface instead of checking   
    // for the jump button directly so this script can also be used by AIs.   
    [System.NonSerialized]   
    public bool inputJump  = false;   
   
    [System.Serializable]   
    public class CharacterMotorMovement   
    {   
        
        // The maximum horizontal speed when moving   
        public float maxForwardSpeed = 10.0f;   
        public float maxSidewaysSpeed = 10.0f;   
        public float maxBackwardsSpeed = 10.0f;   
        
        // Curve for multiplying speed based on slope (negative = downwards)   
        public AnimationCurve slopeSpeedMultiplier = new AnimationCurve(new Keyframe(-90, 1), new Keyframe(0, 1), new Keyframe(90, 0));   
        
        // How fast does the character change speeds?  Higher is faster.   
        public float maxGroundAcceleration = 30.0f;   
        public float maxAirAcceleration = 20.0f;   
        
        // The gravity for the character   
        public float gravity = 10.0f;   
        public float maxFallSpeed = 20.0f;   
        
        // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.   
        // Very handy for organization!   
        
        // The last collision flags returned from controller.Move   
        [System.NonSerialized]   
        public CollisionFlags collisionFlags;   
        
        // We will keep track of the character's current velocity,   
        [System.NonSerialized]   
        public Vector3 velocity;   
        
        // This keeps track of our current velocity while we're not grounded   
        [System.NonSerialized]   
        public Vector3 frameVelocity = Vector3.zero;   
        
        [System.NonSerialized]   
        public Vector3 hitPoint = Vector3.zero;   
        
        [System.NonSerialized]   
        public Vector3 lastHitPoint = new Vector3(Mathf.Infinity, 0, 0);   
    }   
   
    public CharacterMotorMovement movement = new CharacterMotorMovement();   
   
    public enum MovementTransferOnJump {   
        None, // The jump is not affected by velocity of floor at all.   
        InitTransfer, // Jump gets its initial velocity from the floor, then gradualy comes to a stop.   
        PermaTransfer, // Jump gets its initial velocity from the floor, and keeps that velocity until landing.   
        PermaLocked // Jump is relative to the movement of the last touched floor and will move together with that floor.   
    }   
   
    // We will contain all the jumping related variables in one helper class for clarity.      
    [System.Serializable]   
    public class CharacterMotorJumping {   
        // Can the character jump?   
        public bool enabled = true;   
        
        // How high do we jump when pressing jump and letting go immediately   
        public float baseHeight = 1.0f;   
        
        // We add extraHeight units (meters) on top when holding the button down longer while jumping   
        public float extraHeight = 4.1f;   
        
        // How much does the character jump out perpendicular to the surface on walkable surfaces?   
        // 0 means a fully vertical jump and 1 means fully perpendicular.   
        public float perpAmount  = 0.0f;   
        
        // How much does the character jump out perpendicular to the surface on too steep surfaces?   
        // 0 means a fully vertical jump and 1 means fully perpendicular.   
        public float steepPerpAmount = 0.5f;   
        
        // For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector view.   
        // Very handy for organization!   
        
        // Are we jumping? (Initiated with jump button and not grounded yet)   
        // To see if we are just in the air (initiated by jumping OR falling) see the grounded variable.   
        [System.NonSerialized]   
        public bool jumping = false;   
        
        [System.NonSerialized]   
        public bool holdingJumpButton = false;   
        
        // the time we jumped at (Used to determine for how long to apply extra jump power after jumping.)   
        [System.NonSerialized]   
        public float lastStartTime = 0.0f;   
        
        [System.NonSerialized]   
        public float lastButtonDownTime = -100f;   
        
        [System.NonSerialized]   
        public Vector3 jumpDir = Vector3.up;   
    }   
   
    public CharacterMotorJumping  jumping = new CharacterMotorJumping();   
   
    [System.Serializable]   
    public class CharacterMotorMovingPlatform {   
        public bool enabled = true;   
        
        public MovementTransferOnJump movementTransfer = MovementTransferOnJump.PermaTransfer;   
        
        [System.NonSerialized]   
        public Transform hitPlatform;   
        
        [System.NonSerialized]   
        public Transform activePlatform;   
        
        [System.NonSerialized]   
        public Vector3 activeLocalPoint;   
        
        [System.NonSerialized]   
        public Vector3 activeGlobalPoint;   
        
        [System.NonSerialized]   
        public Quaternion activeLocalRotation;   
        
        [System.NonSerialized]   
        public Quaternion activeGlobalRotation;   
        
        [System.NonSerialized]   
        public Matrix4x4 lastMatrix;   
        
        [System.NonSerialized]   
        public Vector3 platformVelocity;   
        
        [System.NonSerialized]   
        public bool newPlatform;   
    }   
   
    public CharacterMotorMovingPlatform movingPlatform  = new CharacterMotorMovingPlatform();   
   
    [System.Serializable]   
    public class CharacterMotorSliding {   
        // Does the character slide on too steep surfaces?   
        public bool enabled = true;   
        
        // How fast does the character slide on steep surfaces?   
        public float slidingSpeed  = 15f;   
        
        // How much can the player control the sliding direction?   
        // If the value is 0.5 the player can slide sideways with half the speed of the downwards sliding speed.   
        public float sidewaysControl = 1.0f;   
        
        // How much can the player influence the sliding speed?   
        // If the value is 0.5 the player can speed the sliding up to 150% or slow it down to 50%.   
        public float speedControl  = 0.4f;   
    }   
   
    public CharacterMotorSliding sliding  = new CharacterMotorSliding();   
   
    [System.NonSerialized]   
    public bool grounded = true;   
   
    [System.NonSerialized]   
    public Vector3 groundNormal = Vector3.zero;   
   
    private Vector3  lastGroundNormal = Vector3.zero;   
   
    private Transform tr;   
   
    private CharacterController  controller ;   
   
    void Awake () {   
        controller = GetComponent <CharacterController>();   
        tr = transform;   
    }   
   
    private void UpdateFunction () {   
        // We copy the actual velocity into a temporary variable that we can manipulate.   
        Vector3 velocity  = movement.velocity;   
        
        // Update velocity based on input   
        velocity = ApplyInputVelocityChange(velocity);   
        
        // Apply gravity and jumping force   
        velocity = ApplyGravityAndJumping (velocity);   
        
        // Moving platform support   
        Vector3 moveDistance  = Vector3.zero;   
        if (MoveWithPlatform()) {   
            Vector3 newGlobalPoint  = movingPlatform.activePlatform.TransformPoint(movingPlatform.activeLocalPoint);   
            moveDistance = (newGlobalPoint - movingPlatform.activeGlobalPoint);   
            if (moveDistance != Vector3.zero)   
                controller.Move(moveDistance);   
            
            // Support moving platform rotation as well:   
            Quaternion newGlobalRotation  = movingPlatform.activePlatform.rotation * movingPlatform.activeLocalRotation;   
            Quaternion rotationDiff  = newGlobalRotation * Quaternion.Inverse(movingPlatform.activeGlobalRotation);   
            
            var yRotation = rotationDiff.eulerAngles.y;   
            if (yRotation != 0) {   
                // Prevent rotation of the local up vector   
                tr.Rotate(0, yRotation, 0);   
            }   
        }   
        
        // Save lastPosition for velocity calculation.   
        Vector3 lastPosition  = tr.position;   
        
        // We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.   
        Vector3 currentMovementOffset = velocity * Time.deltaTime;   
        
        // Find out how much we need to push towards the ground to avoid loosing grouning   
        // when walking down a step or over a sharp change in slope.   
        float pushDownOffset  = Mathf.Max(controller.stepOffset, new Vector3(currentMovementOffset.x, 0, currentMovementOffset.z).magnitude);   
        if (grounded)   
            currentMovementOffset -= pushDownOffset * Vector3.up;   
        
        // Reset variables that will be set by collision function   
        movingPlatform.hitPlatform = null;   
        groundNormal = Vector3.zero;   
        
        // Move our character!   
        movement.collisionFlags = controller.Move (currentMovementOffset);   
        
        movement.lastHitPoint = movement.hitPoint;   
        lastGroundNormal = groundNormal;   
        
        if (movingPlatform.enabled && movingPlatform.activePlatform != movingPlatform.hitPlatform) {   
            if (movingPlatform.hitPlatform != null) {   
                movingPlatform.activePlatform = movingPlatform.hitPlatform;   
                movingPlatform.lastMatrix = movingPlatform.hitPlatform.localToWorldMatrix;   
                movingPlatform.newPlatform = true;   
            }   
        }   
        
        // Calculate the velocity based on the current and previous position.     
        // This means our velocity will only be the amount the character actually moved as a result of collisions.   
        Vector3 oldHVelocity  = new Vector3(velocity.x, 0, velocity.z);   
        movement.velocity = (tr.position - lastPosition) / Time.deltaTime;   
        Vector3 newHVelocity  = new Vector3(movement.velocity.x, 0, movement.velocity.z);   
        
        // The CharacterController can be moved in unwanted directions when colliding with things.   
        // We want to prevent this from influencing the recorded velocity.   
        if (oldHVelocity == Vector3.zero) {   
            movement.velocity = new Vector3(0, movement.velocity.y, 0);   
        }   
        else {   
            float projectedNewVelocity  = Vector3.Dot(newHVelocity, oldHVelocity) / oldHVelocity.sqrMagnitude;   
            movement.velocity = oldHVelocity * Mathf.Clamp01(projectedNewVelocity) + movement.velocity.y * Vector3.up;   
        }   
        
        if (movement.velocity.y < velocity.y - 0.001) {   
            if (movement.velocity.y < 0) {   
                // Something is forcing the CharacterController down faster than it should.   
                // Ignore this   
                movement.velocity.y = velocity.y;   
            }   
            else {   
                // The upwards movement of the CharacterController has been blocked.   
                // This is treated like a ceiling collision - stop further jumping here.   
                jumping.holdingJumpButton = false;   
            }   
        }   
        
        // We were grounded but just loosed grounding   
        if (grounded && !IsGroundedTest()) {   
            grounded = false;   
            
            // Apply inertia from platform   
            if (movingPlatform.enabled &&   
                (movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||   
             movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)   
                ) {   
                movement.frameVelocity = movingPlatform.platformVelocity;   
                movement.velocity += movingPlatform.platformVelocity;   
            }   
            
            SendMessage("OnFall", SendMessageOptions.DontRequireReceiver);   
            // We pushed the character down to ensure it would stay on the ground if there was any.   
            // But there wasn't so now we cancel the downwards offset to make the fall smoother.   
            tr.position += pushDownOffset * Vector3.up;   
        }   
        // We were not grounded but just landed on something   
        else if (!grounded && IsGroundedTest()) {   
            grounded = true;   
            jumping.jumping = false;   
            SubtractNewPlatformVelocity();   
            
            SendMessage("OnLand", SendMessageOptions.DontRequireReceiver);   
        }   
        
        // Moving platforms support   
        if (MoveWithPlatform()) {   
            // Use the center of the lower half sphere of the capsule as reference point.   
            // This works best when the character is standing on moving tilting platforms.   
            movingPlatform.activeGlobalPoint = tr.position + Vector3.up * (controller.center.y - controller.height*0.5f + controller.radius);   
            movingPlatform.activeLocalPoint = movingPlatform.activePlatform.InverseTransformPoint(movingPlatform.activeGlobalPoint);   
            
            // Support moving platform rotation as well:   
            movingPlatform.activeGlobalRotation = tr.rotation;   
            movingPlatform.activeLocalRotation = Quaternion.Inverse(movingPlatform.activePlatform.rotation) * movingPlatform.activeGlobalRotation;   
        }   
    }   
   
    void FixedUpdate () {   
        if (movingPlatform.enabled) {   
            if (movingPlatform.activePlatform != null) {   
                if (!movingPlatform.newPlatform) {   
                    Vector3 lastVelocity  = movingPlatform.platformVelocity;   
                    
                    movingPlatform.platformVelocity = (   
                                                       movingPlatform.activePlatform.localToWorldMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)   
                                                       - movingPlatform.lastMatrix.MultiplyPoint3x4(movingPlatform.activeLocalPoint)   
                                                       ) / Time.deltaTime;   
                }   
                movingPlatform.lastMatrix = movingPlatform.activePlatform.localToWorldMatrix;   
                movingPlatform.newPlatform = false;   
            }   
            else {   
                movingPlatform.platformVelocity = Vector3.zero;   
            }   
        }   
        
        if (useFixedUpdate)   
            UpdateFunction();   
    }   
   
    void Update () {   
        if (!useFixedUpdate)   
            UpdateFunction();   
    }   
   
    private Vector3 ApplyInputVelocityChange (Vector3 velocity) {      
        if (!canControl)   
            inputMoveDirection = Vector3.zero;   
        
        // Find desired velocity   
        Vector3 desiredVelocity;   
        if (grounded && TooSteep()) {   
            // The direction we're sliding in   
            desiredVelocity = new Vector3(groundNormal.x, 0, groundNormal.z).normalized;   
            // Find the input movement direction projected onto the sliding direction   
            var projectedMoveDir = Vector3.Project(inputMoveDirection, desiredVelocity);   
            // Add the sliding direction, the spped control, and the sideways control vectors   
            desiredVelocity = desiredVelocity + projectedMoveDir * sliding.speedControl + (inputMoveDirection - projectedMoveDir) * sliding.sidewaysControl;   
            // Multiply with the sliding speed   
            desiredVelocity *= sliding.slidingSpeed;   
        }   
        else
            desiredVelocity = GetDesiredHorizontalVelocity();   
        
        if (movingPlatform.enabled && movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer) {   
            desiredVelocity += movement.frameVelocity;   
            desiredVelocity.y = 0;   
        }   
        
        if (grounded)   
            desiredVelocity = AdjustGroundVelocityToNormal(desiredVelocity, groundNormal);   
        else
            velocity.y = 0;   
        
        // Enforce max velocity change   
        float maxVelocityChange  = GetMaxAcceleration(grounded) * Time.deltaTime;   
        Vector3 velocityChangeVector  = (desiredVelocity - velocity);   
        if (velocityChangeVector.sqrMagnitude > maxVelocityChange * maxVelocityChange) {   
            velocityChangeVector = velocityChangeVector.normalized * maxVelocityChange;   
        }   
        // If we're in the air and don't have control, don't apply any velocity change at all.   
        // If we're on the ground and don't have control we do apply it - it will correspond to friction.   
        if (grounded || canControl)   
            velocity += velocityChangeVector;   
        
        if (grounded) {   
            // When going uphill, the CharacterController will automatically move up by the needed amount.   
            // Not moving it upwards manually prevent risk of lifting off from the ground.   
            // When going downhill, DO move down manually, as gravity is not enough on steep hills.   
            velocity.y = Mathf.Min(velocity.y, 0);   
        }   
        
        return velocity;   
    }   
   
    private Vector3 ApplyGravityAndJumping (Vector3 velocity) {   
        
        if (!inputJump || !canControl) {   
            jumping.holdingJumpButton = false;   
            jumping.lastButtonDownTime = -100;   
        }   
        
        if (inputJump && jumping.lastButtonDownTime < 0 && canControl)   
            jumping.lastButtonDownTime = Time.time;   
        
        if (grounded)   
            velocity.y = Mathf.Min(0, velocity.y) - movement.gravity * Time.deltaTime;   
        else {   
            velocity.y = movement.velocity.y - movement.gravity * Time.deltaTime;   
            
            // When jumping up we don't apply gravity for some time when the user is holding the jump button.   
            // This gives more control over jump height by pressing the button longer.   
            if (jumping.jumping && jumping.holdingJumpButton) {   
                // Calculate the duration that the extra jump force should have effect.   
                // If we're still less than that duration after the jumping time, apply the force.   
                if (Time.time < jumping.lastStartTime + jumping.extraHeight / CalculateJumpVerticalSpeed(jumping.baseHeight)) {   
                    // Negate the gravity we just applied, except we push in jumpDir rather than jump upwards.   
                    velocity += jumping.jumpDir * movement.gravity * Time.deltaTime;   
                }   
            }   
            
            // Make sure we don't fall any faster than maxFallSpeed. This gives our character a terminal velocity.   
            velocity.y = Mathf.Max (velocity.y, -movement.maxFallSpeed);   
        }   
        
        if (grounded) {   
            // Jump only if the jump button was pressed down in the last 0.2 seconds.   
            // We use this check instead of checking if it's pressed down right now   
            // because players will often try to jump in the exact moment when hitting the ground after a jump   
            // and if they hit the button a fraction of a second too soon and no new jump happens as a consequence,   
            // it's confusing and it feels like the game is buggy.   
            if (jumping.enabled && canControl && (Time.time - jumping.lastButtonDownTime < 0.2)) {   
                grounded = false;   
                jumping.jumping = true;   
                jumping.lastStartTime = Time.time;   
                jumping.lastButtonDownTime = -100;   
                jumping.holdingJumpButton = true;   
               
                // Calculate the jumping direction   
                if (TooSteep())   
                    jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.steepPerpAmount);   
                else
                    jumping.jumpDir = Vector3.Slerp(Vector3.up, groundNormal, jumping.perpAmount);   
               
                // Apply the jumping force to the velocity. Cancel any vertical velocity first.   
                velocity.y = 0;   
                velocity += jumping.jumpDir * CalculateJumpVerticalSpeed (jumping.baseHeight);   
               
                // Apply inertia from platform   
                if (movingPlatform.enabled &&   
                    (movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||   
                 movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)   
                    ) {   
                    movement.frameVelocity = movingPlatform.platformVelocity;   
                    velocity += movingPlatform.platformVelocity;   
                }   
               
                SendMessage("OnJump", SendMessageOptions.DontRequireReceiver);   
            }   
            else {   
                jumping.holdingJumpButton = false;   
            }   
        }   
        
        return velocity;   
    }   
   
    void OnControllerColliderHit (ControllerColliderHit hit) {   
        if (hit.normal.y > 0 && hit.normal.y > groundNormal.y && hit.moveDirection.y < 0) {   
            if ((hit.point - movement.lastHitPoint).sqrMagnitude > 0.001 || lastGroundNormal == Vector3.zero)   
                groundNormal = hit.normal;   
            else
                groundNormal = lastGroundNormal;   
            
            movingPlatform.hitPlatform = hit.collider.transform;   
            movement.hitPoint = hit.point;   
            movement.frameVelocity = Vector3.zero;   
        }   
    }   
   
    private IEnumerator SubtractNewPlatformVelocity () {   
        // When landing, subtract the velocity of the new ground from the character's velocity   
        // since movement in ground is relative to the movement of the ground.   
        if (movingPlatform.enabled &&   
            (movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||   
         movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)   
            ) {   
            // If we landed on a new platform, we have to wait for two FixedUpdates   
            // before we know the velocity of the platform under the character   
            if (movingPlatform.newPlatform) {   
                Transform platform  = movingPlatform.activePlatform;   
                yield return new WaitForFixedUpdate();   
                yield return new WaitForFixedUpdate();   
                if (grounded && platform == movingPlatform.activePlatform)   
                    yield return 1;   
            }   
            movement.velocity -= movingPlatform.platformVelocity;   
        }   
    }   
   
    private bool MoveWithPlatform () {   
        return (   
                movingPlatform.enabled   
                && (grounded || movingPlatform.movementTransfer == MovementTransferOnJump.PermaLocked)   
                && movingPlatform.activePlatform != null
                );   
    }   
   
    private Vector3 GetDesiredHorizontalVelocity () {   
        // Find desired velocity   
        Vector3 desiredLocalDirection  = tr.InverseTransformDirection(inputMoveDirection);   
        float maxSpeed  = MaxSpeedInDirection(desiredLocalDirection);   
        if (grounded) {   
            // Modify max speed on slopes based on slope speed multiplier curve   
            var movementSlopeAngle = Mathf.Asin(movement.velocity.normalized.y)  * Mathf.Rad2Deg;   
            maxSpeed *= movement.slopeSpeedMultiplier.Evaluate(movementSlopeAngle);   
        }   
        return tr.TransformDirection(desiredLocalDirection * maxSpeed);   
    }   
   
    private Vector3 AdjustGroundVelocityToNormal (Vector3 hVelocity, Vector3 groundNormal) {   
        Vector3 sideways  = Vector3.Cross(Vector3.up, hVelocity);   
        return Vector3.Cross(sideways, groundNormal).normalized * hVelocity.magnitude;   
    }   
   
    private bool IsGroundedTest () {   
        return (groundNormal.y > 0.01);   
    }   
   
    float GetMaxAcceleration (bool grounded) {   
        // Maximum acceleration on ground and in air   
        if (grounded)   
            return movement.maxGroundAcceleration;   
        else
            return movement.maxAirAcceleration;   
    }   
   
    float CalculateJumpVerticalSpeed (float targetJumpHeight) {   
        // From the jump height and gravity we deduce the upwards speed   
        // for the character to reach at the apex.   
        return Mathf.Sqrt (2 * targetJumpHeight * movement.gravity);   
    }   
   
    bool IsJumping () {   
        return jumping.jumping;   
    }   
   
    bool IsSliding () {   
        return (grounded && sliding.enabled && TooSteep());   
    }   
   
    bool IsTouchingCeiling () {   
        return (movement.collisionFlags & CollisionFlags.CollidedAbove) != 0;   
    }   
   
    bool IsGrounded () {   
        return grounded;   
    }   
   
    bool TooSteep () {   
        return (groundNormal.y <= Mathf.Cos(controller.slopeLimit * Mathf.Deg2Rad));   
    }   
   
    Vector3 GetDirection () {   
        return inputMoveDirection;   
    }   
   
    void  SetControllable (bool controllable) {   
        canControl = controllable;   
    }   
   
    // Project a direction onto elliptical quater segments based on forward, sideways, and backwards speed.   
    // The function returns the length of the resulting vector.   
    float MaxSpeedInDirection (Vector3 desiredMovementDirection) {   
        if (desiredMovementDirection == Vector3.zero)   
            return 0;   
        else {   
            float zAxisEllipseMultiplier = (desiredMovementDirection.z > 0 ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;   
            Vector3 temp = new Vector3(desiredMovementDirection.x, 0, desiredMovementDirection.z / zAxisEllipseMultiplier).normalized;   
            float length = new Vector3(temp.x, 0, temp.z * zAxisEllipseMultiplier).magnitude * movement.maxSidewaysSpeed;   
            return length;   
        }   
    }   
   
    void SetVelocity (Vector3 velocity) {   
        grounded = false;   
        movement.velocity = velocity;   
        movement.frameVelocity = Vector3.zero;   
        SendMessage("OnExternalVelocity");   
    }   
   
    // Require a character controller to be attached to the same game object   
   
    <A>//@script</A> RequireComponent (CharacterController)   
    <A>//@script</A> AddComponentMenu ("Character/Character Motor")   
   
}</P>






2014-05-29 23:54:32 zay109327402 阅读数 17488
  • Unity3D实战入门之人称射击游戏(TPS)

    这是一套第三人称射击游戏开发的入门基础课程。 本课程以一款小型的第三人称射击游戏为案例,手把手教你如何搭建一款3D射击游戏的雏形。麻雀虽小,五脏俱全,这款小游戏难度不大,但第三人称射击游戏该有的模块、功能它都有涉及。通过案例游戏的开发,学习者可以对第三人称射击游戏入门,对后续复杂大中型3D游戏的开发有实际的借鉴意义。 这套课程,对初次接触3D射击类游戏的学习者而言,是一块极好的跳板。

    1824 人正在学习 去看看 伍晓波

好久没有敲Blog了,谢谢大家的留言、关注、私信等支持,但是我好像已经没有办法让自己继续写以前的博客系列了,因为我发现网上关于unity3D的内容太少了,所以我无法自拔地想写U3D相关的文章!!!


第三人称视角


第三人称视角是什么?很简单,CS就是一种第一人称视角游戏,玩家没有办法看到自己的角色形象,只能观察除开自己之外的游戏内容。第三人称视角那么就明显是能够看到玩家所控制的角色的一种视角。


而且大部分游戏的镜头不能固定不动,肯定是要跟随猪脚,能看到猪脚,但是保持一定的高度和距离,这样的视角才是最好的。


U3D中使用镜头来呈现游戏画面,一般来说是Main Camera。官方有一个使用JS书写的 第三人称镜头跟随脚本和猪脚控制脚本,但是鉴于U3D的js语法太过于诡异,于是我想自己去搞明白怎样来写一个自己用起来爽的第三人称镜头跟随脚本。


==去机场接个人,回来再继续写==



OK,下面分步骤完成这个脚本。关于添加猪脚的gameObject 以及添加CharacterController Component这里就不做解释了,前提是猪脚能够在场景中前后左右上下移动并且不会穿越障碍物然后我们继续往下写。

也就是我们的摄像机现在是固定视角,猪脚可以随意移动和跳跃,如图:


1.创建一个脚本文件CameraFollow.cs




2.接下来,分析我们最想要的效果:

  a,摄像机保持和猪脚一定的高度差(y轴固定差值)和

b.距离差(x,z轴向量的合量相对固定);

  c,面向猪脚的正前方

先完成目的a:

//摄像机固定在猪脚上方10米高度
	public float camera_height=10.0f;
	//摄像机离猪脚大概10米的水平距离
	public float camera_distance=10.0f;

	//摄像机和猪脚的transform属性
	private Transform player;
	private Transform camera;
	// Use this for initialization
	void Start () {
		//初始化
		player=GameObject.FindGameObjectWithTag("Player").transform;
		camera = Camera.main.transform;
	}
	
	// Update is called once per frame
	void Update () {
		//每一帧都改变摄像机的高度
		camera.position = new Vector3 (player.position.x, player.position.y+ camera_height, player.position.z );
	
	}

效果:

我们在脚本中将高度距离两个变量暴露为public,可以在Inspector中修改,先改一个大概满意的高度



目前我们看不到猪脚,原因是摄像机的位置是取的猪脚的X,Z ,只是Y轴加上固定高度。

所以我们需要计算摄像机的X,Z坐标与猪脚的X,Z坐标是一个什么样的关系?

如果单纯的 取猪脚的X,Z坐标然后分别减去distance,是不行的,这样我们只有在某一个方向才能正好在猪脚后方


修改update中的赋值语句为:



那么我们运行游戏,选择到mainCamera,修改他的Y轴旋转度,直到镜头正好时刻在猪脚后方,发现这个角度一直是45°:


所以不难明白,当且仅当摄像机的Y轴偏离45°的时候,x,z各取地平面某一点的值,摄像机的位置在这个x,z坐标基础上减去一个相同的值,摄像机可以正好看到这个点在正中间。


这是为什么?我来画个图示意一下:

忽略掉摄像机的高度差,我们的猪脚在点O(α,0,α)

摄像机在O一撇(0,0,0)

要让摄像机正好看到猪脚在正中间且保持一定距离,那么本来摄像机的正前方是这个坐标系的Z轴正方向,现在改为朝射线O' O方向,那么偏离量很明显由于是个正方形的对角线,(这是透视下的正方形),角度为45°。

问题来了,我们难道要一直保持45°去望着猪脚吗,别忘了我们的摄像机随时要旋转保持正对猪脚的,那么这个位置到底该是多少呢?

我们 先把C完成:随时保证面向猪脚的正前方:


添加这两行代码之后,我们再看看问题出在哪儿:




很明显,摄像机的朝向是与猪脚的正前方朝向一致的,但是位置呢,当切仅当猪脚Y轴旋转度偏离Z轴正方向45°的时候,位置在猪脚正后方,小于45°偏左,大于45°偏右,180°+45°直接跑到猪脚正前面去了。

所以说,我们想要的情况是:

45°时,x 与z各减去 distance 

180°+45°=225°时,x与z各加上distance

0°的时候,x不变,z-distance/sin45°  (为什么,因为实际上45°时候线段O'O的长度其实不是distance而是distance/sin45°,看我画的那个图,勾股定理)

90°的时候,z不变,x-distance/sin45°

所以其实我们这里的定义的distance参数名字和他代表的不一样,实际距离应该是distance/sin45°

所以不难归纳,我们以角度β为变量,得出x与β的函数关系为:

x-=distance*sinβ

z-=distance*cosβ

正好满足我们上面列的4个条件

由于我们代码中需要的三角函数参数是弧度而不是角度,所以这里把角度替换为弧度:

x-=distance*sin(β*π/180)

z-=distance*cos(β*π/180)

所以我们的代码应该修改为:


//看向猪脚
		//camera.LookAt (player);


		//与猪脚的正前方为正前方(只取Y轴的旋转度)
		camera.eulerAngles =new Vector3(camera.eulerAngles.x,
		                               player.eulerAngles.y,
		                               camera.eulerAngles.z);
		//获取当前的镜头的Y轴旋转度
		float angle = camera.eulerAngles.y;

		//计算x轴的距离差:
		float deltaX = camera_distance * Mathf.Sin(angle * Mathf.PI /180 );
		float deltaZ = camera_distance * Mathf.Cos (angle * Mathf.PI / 180);



		//每一帧都改变摄像机的高度
		camera.position = new Vector3 (player.position.x-deltaX,
			                              player.position.y+ camera_height,
			                              player.position.z-deltaZ);


这个lookAt已经不需要了,因为我们的镜头旋转到猪脚的正前方并且位置在他的正后方,那么我们镜头必然已经在看他了

最后的效果是无论猪脚怎样走,我们的镜头都在完美地跟随:







完整脚本代码(比官方的例子精简吧):

using UnityEngine;
using System.Collections;

//添加脚本到component菜单
[AddComponentMenu ("CameraControl/Follow")]
public class CameraFollow : MonoBehaviour {

	//摄像机固定在猪脚上方10米高度
	public float camera_height=10.0f;
	//摄像机离猪脚大概10米的水平距离
	public float camera_distance=10.0f;

	//摄像机和猪脚的transform属性
	private Transform player;
	private Transform camera;
	// Use this for initialization
	void Start () {
		//初始化
		player=GameObject.FindGameObjectWithTag("Player").transform;
		camera = Camera.main.transform;
	}
	
	// Update is called once per frame
	void Update () {


		//看向猪脚
		//camera.LookAt (player);


		//与猪脚的正前方为正前方(只取Y轴的旋转度)
		camera.eulerAngles =new Vector3(camera.eulerAngles.x,
		                               player.eulerAngles.y,
		                               camera.eulerAngles.z);
		//获取当前的镜头的Y轴旋转度
		float angle = camera.eulerAngles.y;

		//计算x轴的距离差:
		float deltaX = camera_distance * Mathf.Sin(angle * Mathf.PI /180 );
		float deltaZ = camera_distance * Mathf.Cos (angle * Mathf.PI / 180);



		//每一帧都改变摄像机的高度
		camera.position = new Vector3 (player.position.x-deltaX,
			                              player.position.y+ camera_height,
			                              player.position.z-deltaZ);

		Debug.Log("angle:"+angle+",deltax:"+deltaX+",deltaZ:"+deltaZ);

		

	
	}
}


没有更多推荐了,返回首页