目录(?)[-]

一效果图
二大概步骤
1. 创建一个plane设置层为Terrain因为后面要判断是否点击的是这个层
2. 准备好人物模型并且将三个脚本拖放到人物上并且将动画文件也拖放好记得看前面提醒哦
  1. ThirdPersonCamera相当于smoothflow
  2. ThirdPersonController修改版
  3. mouseMoveContr鼠标点击人物走动

在漫游游戏中常用的功能就是人物在场景中行走，必要的功能就是鼠标点击地面人物就朝着那个方向行走，键盘方向键前后左右也能控制人物的行走和跳跃，在官方自带的第三人称视角中做了一点修改，官方自带的ThirdPersonController中的摄像机自动指向人物的背面，这样不能看到人物的正面或者侧面，对ThirdPersonController脚本做了修改之后，可以旋转摄像机的视角，可以摄像机跟随，类似smoothfollow的功能。

值得注意提醒的一个，就是动画系统，选择老版本的动画系统，不然会提示找不到模型，因为脚本中用的是老版本的动画系统的代码。

一、效果图

1.鼠标点击地面人物朝着点击的点前进

2.按住wasd和space键也能控制人物的动作

二、大概步骤

1.创建一个plane，设置层为Terrain，因为后面要判断是否点击的是这个层

[csharp] view plaincopyprint? 
 void Update () {  
         MouseDownMover();  
     }  
   
     public void MouseDownMover() {  
         if(Input.GetMouseButtonDown(0)) {  //如果左击  
             LayerMask layerMaskPlayers = 1 << LayerMask.NameToLayer("Terrain");  
             Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);  
             RaycastHit hit;  
             if (Physics.Raycast(ray, out hit,600,layerMaskPlayers.value)) {  
                 point = hit.point;  
                 Instantiate(clickPont, point, transform.rotation);  
                 TimeRealtimeSinceStartup();  
             }  
         }  
     }  

2.准备好人物模型，并且将三个脚本拖放到人物上，并且将动画文件也拖放好，记得看前面提醒哦！

1.ThirdPersonCamera(相当于smoothflow)

[plain] view plaincopyprint? 
 /*  
 Perfect Camera Control Script  By zhoy;  
 Which can be toggled between First-Person Look And Third-Person Look   
 And it also realised freely Look-around  the world with mouse move  
 */  
   
 var cameraTransform : Transform;  
 var distance = 7.0;  
   
 var xSpeed = 100;  
 var ySpeed = 100;  
 var mSpeed = 10;  
   
 var angularSmoothLag = 0.3;  
 var angularMaxSpeed = 15.0;  
   
 var snapSmoothLag = 0.2;  
 var snapMaxSpeed = 720.0;  
   
 var clampHeadPositionScreenSpace = 0.75;  
   
   
 private var _target : Transform;  
   
 //var secondCamera : Camera;  
 private var mainCamera : Camera;  
   
 private var controller : ThirdPersonController;  
   
 private var headOffset    = Vector3.zero;  
 private var centerOffset  = Vector3.zero;  
   
   
 private var dosnap     = false;  
 private var snapped    = false;  
 private var firstPersonLook  = false;  
 private var angleVelocity    = 0.0;  
   
 private var minAngleY   = -45;  
 private var yTopLimit   = -20.0;  
 private var yMinLimit   = -45;  
 private var yMaxLimit   =  45;  
 private var minDistance =  1.2;  
 private var maxDistance =  3.5;  
   
   
 private var current_ver_angle  = 0.0;  
 private var current_hor_angle  = 0.0;  
 private var look_height        = 0.0;  
   
 private var bSeePicture = false;  
 private var curPicturePos:Vector3;  
 private var curPictureRotation:Quaternion;  
 private var curPictureTran: Transform;  
 function Awake ()  
 {  
     //secondCamera.enabled = false;  
     mainCamera = Camera.main;  
     cameraTransform = GameObject.Find("Main Camera").transform;  
     if(!cameraTransform && mainCamera)  
     {  
         cameraTransform = mainCamera.transform;  
     }  
   
     if(!cameraTransform)   
     {  
         Debug.Log("Please assign a camera to the ThirdPersonCamera script.");  
         enabled = false;      
     }  
                   
     _target = transform;  
     if (_target)  
     {  
         controller = _target.GetComponent(ThirdPersonController);  
     }  
       
     if (controller)  
     {  
         var characterController : CharacterController = _target.collider;  
         centerOffset = characterController.bounds.center - _target.position;  
         headOffset = centerOffset;  
           
   
         var look_target = _target.Find("LookTarget");  
         //Debug.Log(look_target);  
         var head_back_pos    = characterController.bounds.max;  
         if(look_target)  
         {  
             head_back_pos = look_target.transform.position;  
         }  
         var hit_test : RaycastHit;    
         var head_top = characterController.bounds.center;  
         head_top.y = characterController.bounds.min.y;  
           
         if(Physics.Raycast(head_top,Vector3.down,hit_test,50))  
         {  
             look_height = head_back_pos.y - hit_test.point.y;     
         }         
       
         //Debug.Log("look_height : " + look_height);  
         headOffset.y = head_back_pos.y - _target.position.y;  
   
         /*下面计算、保存 相机稳定后 的初始位置与方位*/    
         var hor_angle = _target.eulerAngles.y;            
         var rotation_h = Quaternion.Euler (0, hor_angle, 0);      
         var camera_pos = head_back_pos;  
           
         camera_pos += rotation_h * Vector3.back * distance; /*计算相机位置是用 头部为球中心计算的*/  
           
         var offsetToCenter = head_back_pos - camera_pos;  
         var rotation = Quaternion.LookRotation(Vector3(offsetToCenter.x, offsetToCenter.y, offsetToCenter.z));  
         current_hor_angle = 360 - rotation.eulerAngles.y;  
         current_ver_angle = rotation.eulerAngles.x;   
     }  
     else  
     {  
         Debug.Log("Please assign a target to the camera that has a ThirdPersonController script attached.");  
     }  
   
     Cut(_target, centerOffset);   
 }  
   
 function SetVisible(visible)  
 {  
     var renderers = gameObject.GetComponentsInChildren(Renderer);  
     if(visible)  
     {   
         for(var rend:Renderer in renderers){  
             rend.enabled = true;  
         }  
         firstPersonLook = false;  
     }  
     else  
     {   
         for(var rend:Renderer in renderers)  
         {  
             rend.enabled = false;  
         }  
         firstPersonLook = true;   
     }  
 }  
 function Cut (dummyTarget : Transform, dummyCenter : Vector3)  
 {  
     var oldSnapMaxSpeed   = snapMaxSpeed;  
     var oldSnapSmooth     = snapSmoothLag;  
       
     snapMaxSpeed = 10000;  
     snapSmoothLag = 0.001;  
       
     dosnap  = true;  
   
     Apply (transform, Vector3.zero);  
       
     snapMaxSpeed = oldSnapMaxSpeed;  
     snapSmoothLag = oldSnapSmooth;  
 }  
   
 function DebugDrawStuff ()  
 {  
     Debug.DrawLine(_target.position, _target.position + headOffset);  
 }  
   
 function AngleDistance (a : float, b : float)  
 {  
     a = Mathf.Repeat(a, 360);  
     b = Mathf.Repeat(b, 360);  
       
     return Mathf.Abs(b - a);  
 }  
   
   
 function Apply (dummyTarget : Transform, dummyCenter : Vector3)  
 {  
        
     // Early out if we don't have a target  
     if (!controller)  
     {  
         return;  
     }  
     var needGoOn = false;     
     var targetCenter = _target.position + centerOffset;  
     var targetHead = _target.position + headOffset;  
   
     var strength = Input.GetAxis("Mouse ScrollWheel");  
     if(strength != 0)  
     {  
         distance -= strength*mSpeed;  
         distance =  Mathf.Clamp(distance, minDistance, maxDistance);      
         /*  
         if(distance <= 1)  
         {  
             SetVisible(false);  
             minAngleY = -80;          
         }     
         else if(firstPersonLook)  
         {  
             SetVisible(true);  
         }     
         else if(distance < look_height)  
         {  
             minAngleY = (distance - 2) * (yTopLimit - yMinLimit)/(look_height - 2) - yTopLimit;   
             minAngleY = - minAngleY;          
         }  
         else  
         {  
             minAngleY = yMinLimit;  
         }  
         */  
         needGoOn = true;          
     }  
   
     var originalTargetAngle = 360 - _target.eulerAngles.y;    
     current_hor_angle = 360 - cameraTransform.eulerAngles.y;  
     if(!snapped)  
     {  
         var targetAngle = originalTargetAngle;    
         var dis_angle = 0;    
         if (dosnap)  
         {  
             dis_angle = AngleDistance (360 - current_hor_angle, originalTargetAngle);  
             current_hor_angle = Mathf.SmoothDampAngle(current_hor_angle, targetAngle, angleVelocity, snapSmoothLag, snapMaxSpeed);    
         }  
       
             // We are close to the target, so we can stop snapping now!  
         dis_angle= 0;  
         if (dis_angle <= 13)  
         {  
             snapped = true;  
             dosnap  = false;  
       
         }  
         else if(dis_angle < 3)  
         {  
             dosnap  = false;          
         }  
         if(!snapped && !dosnap)  
         {  
             current_hor_angle = Mathf.SmoothDampAngle(current_hor_angle, targetAngle, angleVelocity, angularSmoothLag, angularMaxSpeed);              
         }  
         needGoOn = true;  
     }  
     else  
     {  
             var rotation_h =0;  
             var rotation_v =0;    
         if (Input.GetMouseButton(1)) {  
              rotation_h =  -Input.GetAxis("Mouse X") * xSpeed *0.02;  
              rotation_v =  -Input.GetAxis("Mouse Y") * ySpeed *0.02;      
               
         }  
         needGoOn = needGoOn || (rotation_h != 0 || rotation_v != 0);  
               
         current_hor_angle += rotation_h;      
         current_hor_angle = Mathf.Repeat(current_hor_angle, 360);         
         current_ver_angle += rotation_v;  
         current_ver_angle = Mathf.Clamp (current_ver_angle, minAngleY, yMaxLimit);  
           
     }  
   
     needGoOn = needGoOn || controller.IsMoving();  
     needGoOn = needGoOn || controller.IsJumping();    
     if(!needGoOn)/*没有鼠标键盘事件，返回即可，相机一般不会自动更新。除非未来有其他情形，那时候再添加*/  
     {  
         var mousecl = GetComponent("mouseMoveContr");  
         var mouseMoveFlag = mousecl.getmousemoveFlag();  
         if (!mouseMoveFlag) {  
             return;  
         }  
     }  
           
     var rad_angle_h = (current_hor_angle - 90.0)*Mathf.Deg2Rad;  
     var rad_angle_v = current_ver_angle*Mathf.Deg2Rad;  
     var camera_pos = Vector3.zero;  
     var radius_hor =  distance*Mathf.Cos(rad_angle_v);    
     var slope      = -Mathf.Sin(rad_angle_v);     
       
     camera_pos.x = radius_hor*Mathf.Cos(rad_angle_h) + targetHead.x;/*计算相机位置是用 头部为球中心计算的*/  
     camera_pos.z = radius_hor*Mathf.Sin(rad_angle_h) + targetHead.z;      
     camera_pos.y = -distance*slope + targetHead.y;    
     if(camera_pos.y < targetHead.y - look_height)  
     {  
         camera_pos.y = targetHead.y - look_height;  
     }  
       
     var hit : RaycastHit;  
     var modified = false;  
       
     var hor_dis     = 0.0;  
       
     if(camera_pos.y < targetCenter.y)  
     {     
         var testPt = camera_pos;  
         testPt.y = targetCenter.y;    
         if(Physics.Raycast(testPt,Vector3.down,hit,50))/*这个检测必须进行，不能完全指望后面的检测，否则会有微小的显示问题。一般发生在摄像机贴近地面跑动时*/  
         {  
             if(camera_pos.y < hit.point.y + 0.5)/*偏移0.5.防止过于接近地面，并且在地面上面的情况，会因为摄像机近截面问题。导致显示地下的内容*/  
             {  
                 modified = true;                      
             }                     
         }     
     }  
     if(modified)  
     {         
         hor_dis  = Vector3.Distance(targetCenter,Vector3(camera_pos.x,targetCenter.y,camera_pos.z));              
         camera_pos = hit.point;  
         camera_pos.y = (slope > 0.95)?hit.point.y:(camera_pos.y + hor_dis/maxDistance);  
         //摄像头在脚下的时候，hor_dis几乎为0  
         modified = false;  
         //Debug.Log("hit down.....camera_pos : " +camera_pos);        
     }     
   
     var real_dis = Vector3.Distance(targetCenter,camera_pos);  
     var direction = camera_pos - targetCenter;  
   
     if(Physics.Raycast(targetCenter,direction,hit,real_dis) && hit.collider.gameObject != gameObject)  
     {  
 //      modified = false;  
 //      if(hit.collider.bounds.size.magnitude <= 15) {  
 //          modified = false;     
 //      } else if (hit.collider.gameObject.tag == "bridge") {  
 //          camera_pos.y = camera_pos.y + 2.5;  
 //      } else if (hit.collider.gameObject.tag == "through"){  
 //          modified = false;  
 //      } else {  
 //          modified = true;  
 //      }  
 //      Debug.LogError(hit.point.y < targetHead.y);  
         camera_pos = hit.point;  
         if(hit.point.y < targetHead.y){  
             camera_pos.y = targetHead.y;  
 //          Debug.LogError(camera_pos);  
         }  
     }  
 //    
 //  if(modified)  
 //  {     
 //      hor_dis  = Vector3.Distance(targetCenter,Vector3(camera_pos.x,targetCenter.y,camera_pos.z));              
 //      camera_pos   = hit.point;  
 //      camera_pos.y = (slope > 0.95)?hit.point.y:(camera_pos.y + hor_dis/maxDistance);/*摄像头在脚下的时候，hor_dis几乎为0*/   
 //  }     
     cameraTransform.position = camera_pos;    
     var offsetToCenter = targetHead - cameraTransform.position;  
     cameraTransform.rotation = Quaternion.LookRotation(Vector3(offsetToCenter.x, offsetToCenter.y, offsetToCenter.z));  
     Debug.DrawLine(targetCenter, camera_pos, Color.red);  
 }  
   
 function EventMouseClicked(){  
 //  Debug.LogError(Input.mousePosition);  
     var mousePos:Vector3 = Input.mousePosition;  
     var ray:Ray;  
     ray = Camera.main.ScreenPointToRay(mousePos);  
     var hitInfo:RaycastHit;  
     var cameraTran:Transform;  
     cameraTran = Camera.main.transform;  
     if(Input.GetMouseButtonDown(0)){  
         if(Physics.Raycast(ray, hitInfo, 50f, (1<<9))){  
             Debug.LogError(hitInfo.transform.gameObject.layer);  
 //          curPicturePos = hitInfo.point;  
 //          curPicturePos = hitInfo.transform.Find("CameraPos").position;  
 //          curPictureRotation = hitInfo.transform.Find("CameraPos").rotation;  
             curPictureTran = hitInfo.transform.Find("CameraPos");  
             bSeePicture = !bSeePicture;  
             if(bSeePicture){  
                 GetComponent(ThirdPersonController).enabled = false;  
             }else{  
                 GetComponent(ThirdPersonController).enabled = true;  
             }  
         }  
     }  
 }  
 function LateUpdate ()   
 {  
     if (Input.GetKeyUp (KeyCode.Tab))  
     {  
         var hit2 : RaycastHit;   
         Debug.Log("Camera Pos.y : " + cameraTransform.position.y);  
         var testPt = cameraTransform.position;  
         testPt.y = 50;    
         if(Physics.Raycast(testPt,Vector3.down,hit2,50))  
         {  
             Debug.Log("hit2.point.y : " + hit2.point.y);          
         }         
     }  
     EventMouseClicked();  
     if(!bSeePicture){  
         Apply (transform, Vector3.zero);  
     }else{  
 //      Camera.main.transform.position = transform.position;  
 //      Camera.main.transform.position.y = curPicturePos.y;  
         Camera.main.transform.rotation = Quaternion.LookRotation(curPicturePos - Camera.main.transform.position);  
 //      Camera.main.transform.rotation = transform.rotation;  
 //      Camera.main.transform.position = curPicturePos;  
 //      Camera.main.transform.rotation = curPictureRotation;  
         Camera.main.transform.rotation = curPictureTran.rotation;  
         Camera.main.transform.position = curPictureTran.position;  
     }  
 }  
   
 function GetCenterOffset ()  
 {  
     return centerOffset;  
 }  
 /*  
 function UpdateSecondCamPos(lookat,campos)  
 {  
     var ccnter  = Vector3.Lerp(campos,lookat,0.5);  
     var forward = ccnter - campos;  
     forward = forward.normalized;  
     forward.y = 0;  
     var right = Vector3.Cross (Vector3.up, forward);  
     var setpos = ccnter + right*30;  
       
     secondCamera.transform.position = setpos;  
     var offset = ccnter - setpos;  
     //Debug.DrawRay(campos,lookat - campos,Color.red,100000);  
     var t1 = Time.time;  
     GameObject.Find("TestObject").transform.position = campos;  
     var t2= Time.time;  
       
     secondCamera.transform.rotation = Quaternion.LookRotation(Vector3(offset.x, offset.y, offset.z));     
 }  
 */  
 /*  
 if (Input.GetKeyUp (KeyCode.Tab))  
 {  
     var hit2 : RaycastHit;   
     Debug.Log("Camera Pos.y : " + cameraTransform.position.y);  
     var testPt = cameraTransform.position;  
     testPt.y = 50;    
     if(Physics.Raycast(testPt,Vector3.down,hit2,50))  
     {  
         Debug.Log("hit2.point.y : " + hit2.point.y);          
     }         
   
     if(mainCamera.enabled)  
     {  
         controller.SwitchCamera(secondCamera);   
   
     }  
     else  
     {  
         controller.SwitchCamera(mainCamera);                      
     }  
   
 }     
 */  
     

2.ThirdPersonController(修改版)

[plain] view plaincopyprint? 
 // Require a character controller to be attached to the same game object  
 @script RequireComponent(CharacterController)  
   
 public var idleAnimation : AnimationClip;  
 public var walkAnimation : AnimationClip;  
 public var runAnimation : AnimationClip;  
 public var jumpPoseAnimation : AnimationClip;  
   
 public var kneeAnimation : AnimationClip;  
   
 public var walkMaxAnimationSpeed : float = 0.75;  
 public var trotMaxAnimationSpeed : float = 1.0;  
 public var runMaxAnimationSpeed : float = 1.0;  
 public var jumpAnimationSpeed : float = 1.15;  
 public var landAnimationSpeed : float = 1.0;  
   
 private var _animation : Animation;  
   
 enum CharacterState {  
     Idle = 0,  
     Walking = 1,  
     Trotting = 2,  
     Running = 3,  
     Jumping = 4,  
 }  
   
 private var _characterState : CharacterState;  
   
 // The speed when walking  
 var walkSpeed = 2.0;  
 // after trotAfterSeconds of walking we trot with trotSpeed  
 var trotSpeed = 4.0;  
 // when pressing "Fire3" button (cmd) we start running  
 var runSpeed = 6.0;  
   
 var inAirControlAcceleration = 3.0;  
   
 // How high do we jump when pressing jump and letting go immediately  
 var jumpHeight = 0.5;  
   
 // The gravity for the character  
 var gravity = 20.0;  
 // The gravity in controlled descent mode  
 var speedSmoothing = 10.0;  
 var rotateSpeed = 500.0;  
 var trotAfterSeconds = 3.0;  
   
 var canJump = true;  
   
 private var jumpRepeatTime = 0.05;  
 private var jumpTimeout = 0.15;  
 private var groundedTimeout = 0.25;  
   
 // The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.  
 private var lockCameraTimer = 0.0;  
   
 // The current move direction in x-z  
 private var moveDirection = Vector3.zero;  
 // The current vertical speed  
 private var verticalSpeed = 0.0;  
 // The current x-z move speed  
 private var moveSpeed = 0.0;  
   
 // The last collision flags returned from controller.Move  
 private var collisionFlags : CollisionFlags;   
   
 // Are we jumping? (Initiated with jump button and not grounded yet)  
 private var jumping = false;  
 private var jumpingReachedApex = false;  
   
 // Are we moving backwards (This locks the camera to not do a 180 degree spin)  
 private var movingBack = false;  
 // Is the user pressing any keys?  
 private var isMoving = false;  
 // When did the user start walking (Used for going into trot after a while)  
 private var walkTimeStart = 0.0;  
 // Last time the jump button was clicked down  
 private var lastJumpButtonTime = -10.0;  
 // Last time we performed a jump  
 private var lastJumpTime = -1.0;  
   
   
 // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)  
 private var lastJumpStartHeight = 0.0;  
   
   
 private var inAirVelocity = Vector3.zero;  
   
 private var lastGroundedTime = 0.0;  
   
   
 private var isControllable = true;  
   
 private var activeCamera : Camera;  
   
 //private var scenesCode = "S";  
   
 function Start() {  
     //scenesCode = GameObject.Find("Main Camera").GetComponent("createusers").getScenesCode();  
 }  
   
 function LateUpdate() {  
       
 }  
   
 function Awake ()  
 {  
     moveDirection = transform.TransformDirection(Vector3.forward);  
       
     _animation = GetComponent(Animation);  
     if(!_animation)  
         Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");  
       
     /*  
 public var idleAnimation : AnimationClip;  
 public var walkAnimation : AnimationClip;  
 public var runAnimation : AnimationClip;  
 public var jumpPoseAnimation : AnimationClip;     
     */  
     if(!idleAnimation) {  
         _animation = null;  
         Debug.Log("No idle animation found. Turning off animations.");  
     }  
     if(!walkAnimation) {  
         _animation = null;  
         Debug.Log("No walk animation found. Turning off animations.");  
     }  
     if(!runAnimation) {  
         _animation = null;  
         Debug.Log("No run animation found. Turning off animations.");  
     }  
     if(!jumpPoseAnimation && canJump) {  
         _animation = null;  
         Debug.Log("No jump animation found and the character has canJump enabled. Turning off animations.");  
     }  
     activeCamera = Camera.main;  
     Screen.lockCursor = false;            
 }  
 /*  
 function SwitchCamera(camera:Camera)  
 {  
     activeCamera.enabled = false;  
     activeCamera = camera;  
     activeCamera.enabled = true;  
 }  
 */  
 function UpdateSmoothedMovementDirection ()  
 {  
     var cameraTransform = activeCamera.transform;  
     var grounded = IsGrounded();  
       
     // Forward vector relative to the camera along the x-z plane      
     var forward = cameraTransform.TransformDirection(Vector3.forward);  
     forward.y = 0;  
     forward = forward.normalized;  
   
     // Right vector relative to the camera  
     // Always orthogonal to the forward vector  
     var right = Vector3(forward.z, 0, -forward.x);  
   
     var v = Input.GetAxisRaw("Vertical");  
     var h = Input.GetAxisRaw("Horizontal");  
   
     // Are we moving backwards or looking backwards  
     if (v < -0.2)  
         movingBack = true;  
     else  
         movingBack = false;  
       
     var wasMoving = isMoving;  
     isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;  
           
     // Target direction relative to the camera  
     var targetDirection = h * right + v * forward;  
   
     // Grounded controls  
     if (grounded)  
     {  
         // Lock camera for short period when transitioning moving & standing still  
         lockCameraTimer += Time.deltaTime;  
         if (isMoving != wasMoving)  
             lockCameraTimer = 0.0;  
   
         // We store speed and direction seperately,  
         // so that when the character stands still we still have a valid forward direction  
         // moveDirection is always normalized, and we only update it if there is user input.  
         if (targetDirection != Vector3.zero)  
         {  
             // If we are really slow, just snap to the target direction  
             if (moveSpeed < walkSpeed * 0.9 && grounded)  
             {  
                 moveDirection = targetDirection.normalized;  
             }  
             // Otherwise smoothly turn towards it  
             else  
             {  
                 moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);  
                   
                 moveDirection = moveDirection.normalized;  
             }  
         }  
       
         // Smooth the speed based on the current target direction  
         var curSmooth = speedSmoothing * Time.deltaTime;  
           
         // Choose target speed  
         //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways  
         var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);  
       
         _characterState = CharacterState.Idle;  
           
         // Pick speed modifier  
         if (Input.GetKey (KeyCode.LeftShift) || Input.GetKey (KeyCode.RightShift))  
         {  
             targetSpeed *= runSpeed;  
             _characterState = CharacterState.Running;  
         }  
         else if (Time.time - trotAfterSeconds > walkTimeStart)  
         {  
             targetSpeed *= trotSpeed;  
             _characterState = CharacterState.Trotting;  
         }  
         else  
         {  
             targetSpeed *= walkSpeed;  
             _characterState = CharacterState.Walking;  
         }  
           
         moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);  
           
         // Reset walk time start when we slow down  
         if (moveSpeed < walkSpeed * 0.3)  
             walkTimeStart = Time.time;  
     }  
     // In air controls  
     else  
   
     {  
         // Lock camera while in air  
         if (jumping)  
             lockCameraTimer = 0.0;  
   
         if (isMoving)  
             inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;  
     }  
           
 }  
   
   
 function ApplyJumping ()  
 {  
     // Prevent jumping too fast after each other  
     if (lastJumpTime + jumpRepeatTime > Time.time)  
         return;  
   
     if (IsGrounded())   
     {  
         // Jump  
         // - Only when pressing the button down  
         // - With a timeout so you can press the button slightly before landing       
         if (canJump && Time.time < lastJumpButtonTime + jumpTimeout) {  
             verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);  
             SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);  
         }  
     }  
 }  
   
   
 function ApplyGravity ()  
 {  
     if (isControllable) // don't move player at all if not controllable.  
     {  
         // Apply gravity  
         var jumpButton = Input.GetButton("Jump");  
           
           
         // When we reach the apex of the jump we send out a message  
         if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0)  
         {  
             jumpingReachedApex = true;  
             SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);  
         }  
       
         if (IsGrounded ())  
             verticalSpeed = 0.0;  
         else  
             verticalSpeed -= gravity * Time.deltaTime;  
     }  
 }  
   
 function CalculateJumpVerticalSpeed (targetJumpHeight : float)  
 {  
     // From the jump height and gravity we deduce the upwards speed   
     // for the character to reach at the apex.  
     return Mathf.Sqrt(2 * targetJumpHeight * gravity);  
 }  
   
 function DidJump ()  
 {  
     jumping = true;  
     jumpingReachedApex = false;  
     lastJumpTime = Time.time;  
     lastJumpStartHeight = transform.position.y;  
     lastJumpButtonTime = -10;  
       
     _characterState = CharacterState.Jumping;  
 }  
   
 function Update() {  
     if (_animation.IsPlaying("kneel")) {  
         return;  
     }  
     if (!isControllable)  
     {  
         // kill all inputs if not controllable.  
         Input.ResetInputAxes();  
     }  
   
     if (Input.GetButtonDown ("Jump") && !jumping)  
     {  
         lastJumpButtonTime = Time.time;  
     }  
     if (Input.GetKeyUp (KeyCode.Escape))  
     {  
         Screen.lockCursor = !Screen.lockCursor;       
     }  
   
     UpdateSmoothedMovementDirection();  
       
     // Apply gravity  
     // - extra power jump modifies gravity  
     // - controlledDescent mode modifies gravity  
     ApplyGravity ();  
   
     // Apply jumping logic  
     ApplyJumping ();  
     //鼠标移动  
     var mousecl = GetComponent("mouseMoveContr");  
     var mouseMoveFlag = mousecl.getmousemoveFlag();  
       
     if (mouseMoveFlag){  
         if (checkKeyDown()) {  
             mousecl.setMouseMoveFlag();  
         } else {  
             moveDirection = mousecl.getMovement();  
             moveSpeed = mousecl.getMoveSpeed();  
             if (moveSpeed == 4.2) {  
                 _characterState = CharacterState.Running;  
             }  
         }  
     }  
     // Calculate actual motion  
     var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;  
     movement *= Time.deltaTime;  
       
     // Move the controller  
     var controller : CharacterController = GetComponent(CharacterController);  
       
     collisionFlags = controller.Move(movement);  
     if (_characterState == CharacterState.Running) {  
         if (mouseMoveFlag){  
             if(controller.velocity.sqrMagnitude < 100) {  
                 _characterState = CharacterState.Walking;  
             }  
         }  
     }  
     // ANIMATION sector  
     if(_animation) {  
         if(_characterState == CharacterState.Jumping)   
         {  
             if(!jumpingReachedApex) {  
                 _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;  
                 _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;  
                 _animation.CrossFade(jumpPoseAnimation.name);  
             } else {  
                 _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;  
                 _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;  
                 _animation.CrossFade(jumpPoseAnimation.name);                 
             }  
         }   
         else   
         {  
           
             if(controller.velocity.sqrMagnitude < 0.1) {  
                 _animation.CrossFade(idleAnimation.name);  
             }  
             else   
             {  
                 if(_characterState == CharacterState.Running) {  
                     _animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);  
                     _animation.CrossFade(runAnimation.name);      
                 }  
                 else if(_characterState == CharacterState.Trotting) {  
                     _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed);  
                     _animation.CrossFade(walkAnimation.name);     
                 }  
                 else if(_characterState == CharacterState.Walking) {  
                     _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);  
                     _animation.CrossFade(walkAnimation.name);     
                 }  
                   
             }  
         }  
     }  
     // ANIMATION sector  
       
     // Set rotation to the move direction  
     if (IsGrounded())  
     {  
           
         transform.rotation = Quaternion.LookRotation(moveDirection);  
   
     }     
     else  
     {  
         var xzMove = movement;  
         xzMove.y = 0;  
         if (xzMove.sqrMagnitude > 0.001)  
         {  
             transform.rotation = Quaternion.LookRotation(xzMove);  
         }  
     }     
       
     // We are in jump mode but just became grounded  
     if (IsGrounded())  
     {  
         lastGroundedTime = Time.time;  
         inAirVelocity = Vector3.zero;  
         if (jumping)  
         {  
             jumping = false;  
             SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);  
         }  
     }  
 }  
   
 function OnControllerColliderHit (hit : ControllerColliderHit )  
 {  
 //  Debug.DrawRay(hit.point, hit.normal);  
     if (hit.moveDirection.y > 0.01)   
         return;  
 }  
   
 function GetSpeed () {  
     return moveSpeed;  
 }  
   
 function IsJumping () {  
     return jumping;  
 }  
   
 function IsGrounded () {  
     return (collisionFlags & CollisionFlags.CollidedBelow) != 0;  
 }  
   
 function GetDirection () {  
     return moveDirection;  
 }  
   
 function IsMovingBackwards () {  
     return movingBack;  
 }  
   
 function GetLockCameraTimer ()   
 {  
     return lockCameraTimer;  
 }  
 function GetCharacterState() :CharacterState  
 {  
     return _characterState;  
 }  
   
 function IsMoving ()  : boolean  
 {  
     return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5;  
 }  
   
 function HasJumpReachedApex ()  
 {  
     return jumpingReachedApex;  
 }  
   
 function IsGroundedWithTimeout ()  
 {  
     return lastGroundedTime + groundedTimeout > Time.time;  
 }  
   
 function Reset ()  
 {  
     gameObject.tag = "Player";  
 }  
 function checkKeyDown():boolean {  
     if (Input.GetKey(KeyCode.W)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.A)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.S)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.D)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.UpArrow)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.DownArrow)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.RightArrow)) {  
         return true;  
     }  
     if (Input.GetKey(KeyCode.LeftArrow)) {  
         return true;  
     }  
     return false;  
 }  

3.mouseMoveContr（鼠标点击人物走动）

[csharp] view plaincopyprint? 
 using UnityEngine;  
 using System.Collections;  
   
 public class mouseMoveContr : MonoBehaviour {  
     public const int PLAY_IDLE = 0;  
     public const int PLAY_WALK = 1;  
     public const int PLAY_RUN  = 2;  
     public const int PLAY_KNEE  = 3;  
     //public GameObject clickPont;  
     public float walkSpeed = 2;  
     public float runSpeed = 4.5f;  
       
     private bool moveflag = false;  
       
     private int gameState = 0;  
     private Vector3 point;  
     private float time;  
     private Vector3 v;  
     private Vector3 lotav;  
     private float moveSpeed = 0.0f;  
       
     void Start () {  
         SetGameState(PLAY_IDLE);  
     }  
       
     void Update () {  
         MouseDownMover();  
     }  
     public void MouseDownMover() {  
         if(Input.GetMouseButtonDown(0)) {  
             LayerMask layerMaskPlayers = 1 << LayerMask.NameToLayer("Terrain");  
             Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);  
             RaycastHit hit;  
             if (Physics.Raycast(ray, out hit,600,layerMaskPlayers.value)) {  
                 point = hit.point;  
                 //Instantiate(clickPont, point, transform.rotation);  
                 TimeRealtimeSinceStartup();  
             }  
         }  
     }  
     public void TimeRealtimeSinceStartup() {  
         if(Time.realtimeSinceStartup - time <=0.2f) {  
             SetGameState(PLAY_RUN);  
         } else {  
             SetGameState(PLAY_WALK);  
         }  
         time = Time.realtimeSinceStartup;  
     }  
     public void FixedUpdate() {  
         switch(gameState) {  
             case PLAY_IDLE:  
                 break;  
             case PLAY_WALK:  
                 SetGameState(PLAY_WALK);  
                 Move(walkSpeed);  
                 break;  
             case PLAY_RUN:  
                 SetGameState(PLAY_RUN);  
                 Move(runSpeed);  
                 break;  
         }  
     }  
     public void SetGameState(int  state) {  
         switch(state) {  
             case PLAY_IDLE:  
                 point = transform.position;  
                 //animation.Play("idle");  
                 break;  
             case PLAY_WALK:  
                 //animation.Play("walk");  
                 break;  
             case PLAY_RUN:  
                 //animation.Play("run");  
                 break;  
         }  
         gameState = state;  
     }  
     public void Move(float speed) {  
         if(Mathf.Abs(Vector3.Distance(point, transform.position))>=0.2f) {  
             moveflag = true;  
             CharacterController controller  = GetComponent<CharacterController>();  
             v = Vector3.ClampMagnitude(point -  transform.position,speed);  
             v.y = 0;  
         } else {  
             moveflag = false;  
             SetGameState(PLAY_IDLE);  
         }  
         moveSpeed = speed;  
     }  
     public bool getmousemoveFlag() {  
         return moveflag;  
     }  
         public void setMouseMoveFlag() {  
         moveflag = false;  
         point = transform.position;  
     }  
     public Vector3 getMovement() {  
         return v;  
     }  
     public float getMoveSpeed() {  
         return moveSpeed;  
     }  
 }  