[unity3d]鼠标点击地面人物自动走动(也包含按键wasd&space控制)

在漫游游戏中常用的功能就是人物在场景中行走，必要的功能就是鼠标点击地面人物就朝着那个方向行走，键盘方向键前后左右也能控制人物的行走和跳跃，在官方自带的第三人称视角中做了一点修改，官方自带的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;

}

}