CharacterMotor.cs
using UnityEngine;
using System.Collections; /**
* @Author : www.xuanyusong.com
*/ [RequireComponent(typeof(CharacterController))]
[AddComponentMenu("Character/Character Motor")] 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(-, ), new Keyframe(, ), new Keyframe(, )); // 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, , );
} 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 != ) {
// Prevent rotation of the local up vector
tr.Rotate(, yRotation, );
}
} // 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, , 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, , velocity.z);
movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
Vector3 newHVelocity = new Vector3(movement.velocity.x, , 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(, movement.velocity.y, );
}
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 < ) {
// 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, , 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 = ;
} if (grounded)
desiredVelocity = AdjustGroundVelocityToNormal(desiredVelocity, groundNormal);
else
velocity.y = ; // 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, );
} return velocity;
} private Vector3 ApplyGravityAndJumping (Vector3 velocity) { if (!inputJump || !canControl) {
jumping.holdingJumpButton = false;
jumping.lastButtonDownTime = -;
} if (inputJump && jumping.lastButtonDownTime < && canControl)
jumping.lastButtonDownTime = Time.time; if (grounded)
velocity.y = Mathf.Min(, 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 = -;
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 = ;
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 > && hit.normal.y > groundNormal.y && hit.moveDirection.y < ) {
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 ;
}
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 ( * targetJumpHeight * movement.gravity);
} bool IsJumping () {
return jumping.jumping;
} bool IsSliding () {
return (grounded && sliding.enabled && TooSteep());
} bool IsTouchingCeiling () {
return (movement.collisionFlags & CollisionFlags.CollidedAbove) != ;
} 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 ;
else {
float zAxisEllipseMultiplier = (desiredMovementDirection.z > ? movement.maxForwardSpeed : movement.maxBackwardsSpeed) / movement.maxSidewaysSpeed;
Vector3 temp = new Vector3(desiredMovementDirection.x, , desiredMovementDirection.z / zAxisEllipseMultiplier).normalized;
float length = new Vector3(temp.x, , 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 //@script RequireComponent (CharacterController)
//@script AddComponentMenu ("Character/Character Motor") }
FPSInputController.cs 内涵双摇杆控制脚本,请注意
using UnityEngine;
using System.Collections; /**
* @Author : www.xuanyusong.com
*/ [RequireComponent(typeof(CharacterMotor))]
[AddComponentMenu("Character/FPS Input Controller")] public class FPSInputController : MonoBehaviour { private CharacterMotor motor ; // Use this for initialization
void Awake () {
motor = GetComponent<CharacterMotor>();
} // Update is called once per frame
void Update ()
{
keyMove ();
//joyMove ();
} void joyMove()
{
Vector2 getPosition = gameObject.GetComponent<JoyStick>().getPositions();
// Get the input vector from kayboard or analog stick
Vector3 directionVector = new Vector3(getPosition.y, , getPosition.x); if (directionVector != Vector3.zero) {
// Get the length of the directon vector and then normalize it
// Dividing by the length is cheaper than normalizing when we already have the length anyway
var directionLength = directionVector.magnitude;
directionVector = directionVector / directionLength; // Make sure the length is no bigger than 1
directionLength = Mathf.Min(, directionLength); // Make the input vector more sensitive towards the extremes and less sensitive in the middle
// This makes it easier to control slow speeds when using analog sticks
directionLength = directionLength * directionLength; // Multiply the normalized direction vector by the modified length
directionVector = directionVector * directionLength;
} // Apply the direction to the CharacterMotor
motor.inputMoveDirection = transform.rotation * directionVector;
//motor.inputJump = Input.GetButton("Jump");
} void keyMove()
{
// Get the input vector from kayboard or analog stick
Vector3 directionVector = new Vector3(Input.GetAxis("Horizontal"), , Input.GetAxis("Vertical")); if (directionVector != Vector3.zero) {
// Get the length of the directon vector and then normalize it
// Dividing by the length is cheaper than normalizing when we already have the length anyway
var directionLength = directionVector.magnitude;
directionVector = directionVector / directionLength; // Make sure the length is no bigger than 1
directionLength = Mathf.Min(, directionLength); // Make the input vector more sensitive towards the extremes and less sensitive in the middle
// This makes it easier to control slow speeds when using analog sticks
directionLength = directionLength * directionLength; // Multiply the normalized direction vector by the modified length
directionVector = directionVector * directionLength;
} // Apply the direction to the CharacterMotor
motor.inputMoveDirection = transform.rotation * directionVector;
motor.inputJump = Input.GetButton("Jump");
} }
MouseLook.cs
内涵双摇杆控制脚本,请注意
using System.Collections; /// MouseLook rotates the transform based on the mouse delta.
/// Minimum and Maximum values can be used to constrain the possible rotation /// To make an FPS style character:
/// - Create a capsule.
/// - Add the MouseLook script to the capsule.
/// -> Set the mouse look to use LookX. (You want to only turn character but not tilt it)
/// - Add FPSInputController script to the capsule
/// -> A CharacterMotor and a CharacterController component will be automatically added. /// - Create a camera. Make the camera a child of the capsule. Reset it's transform.
/// - Add a MouseLook script to the camera.
/// -> Set the mouse look to use LookY. (You want the camera to tilt up and down like a head. The character already turns.)
[AddComponentMenu("Camera-Control/Mouse Look")]
public class MouseLook : MonoBehaviour { public enum RotationAxes { MouseXAndY = , MouseX = , MouseY = }
public RotationAxes axes = RotationAxes.MouseXAndY;
public float sensitivityX = 15F;
public float sensitivityY = 15F; public float minimumX = -360F;
public float maximumX = 360F; public float minimumY = -60F;
public float maximumY = 60F; float rotationY = 0F; void Update ()
{mouseMove ();
//joyMove2(); } void joyMove2()
{
if (axes == RotationAxes.MouseXAndY)
{
Vector2 getPosition = gameObject.GetComponent<JoyStick>().getPositions(); float rotationX = transform.localEulerAngles.y + getPosition.x * sensitivityX; rotationY += getPosition.y * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY); transform.localEulerAngles = new Vector3(-rotationY, rotationX, );
}
else if (axes == RotationAxes.MouseX)
{
Vector2 getPosition = transform.FindChild("Main Camera").GetComponent<JoyStick>().getPositions();
transform.Rotate(, getPosition.x * sensitivityX, );
}
else
{
Vector2 getPosition = gameObject.GetComponent<JoyStick>().getPositions();
rotationY += getPosition.y * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY); transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, );
}
} void mouseMove()
{if (axes == RotationAxes.MouseXAndY)
{
float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX; rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY); transform.localEulerAngles = new Vector3(-rotationY, rotationX, );
}
else if (axes == RotationAxes.MouseX)
{
transform.Rotate(, Input.GetAxis("Mouse X") * sensitivityX, );
}
else
{
rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY); transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, );
}
} void Start ()
{
// Make the rigid body not change rotation
if (GetComponent<Rigidbody>())
GetComponent<Rigidbody>().freezeRotation = true;
}
}
PlatformInputController.cs
using UnityEngine;
using System.Collections; /**
* @Author : www.xuanyusong.com
*/ [RequireComponent(typeof(CharacterController))]
[AddComponentMenu("Character/Platform Input Controller")]
public class PlatformInputController : MonoBehaviour { public bool autoRotate = true;
public float maxRotationSpeed = ; private CharacterMotor motor ; // Use this for initialization
void Awake () {
motor = GetComponent<CharacterMotor>();
} // Update is called once per frame
void Update () {
// Get the input vector from kayboard or analog stick
Vector3 directionVector = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), ); if (directionVector != Vector3.zero) {
// Get the length of the directon vector and then normalize it
// Dividing by the length is cheaper than normalizing when we already have the length anyway
var directionLength = directionVector.magnitude;
directionVector = directionVector / directionLength; // Make sure the length is no bigger than 1
directionLength = Mathf.Min(, directionLength); // Make the input vector more sensitive towards the extremes and less sensitive in the middle
// This makes it easier to control slow speeds when using analog sticks
directionLength = directionLength * directionLength; // Multiply the normalized direction vector by the modified length
directionVector = directionVector * directionLength;
} // Rotate the input vector into camera space so up is camera's up and right is camera's right
directionVector = Camera.main.transform.rotation * directionVector; // Rotate input vector to be perpendicular to character's up vector
var camToCharacterSpace = Quaternion.FromToRotation(-Camera.main.transform.forward, transform.up);
directionVector = (camToCharacterSpace * directionVector); // Apply the direction to the CharacterMotor
motor.inputMoveDirection = directionVector;
motor.inputJump = Input.GetButton("Jump"); // Set rotation to the move direction
if (autoRotate && directionVector.sqrMagnitude > 0.01) {
Vector3 newForward = ConstantSlerp(
transform.forward,
directionVector,
maxRotationSpeed * Time.deltaTime
);
newForward = ProjectOntoPlane(newForward, transform.up);
transform.rotation = Quaternion.LookRotation(newForward, transform.up);
}
} Vector3 ProjectOntoPlane (Vector3 v, Vector3 normal) {
return v - Vector3.Project(v, normal);
} Vector3 ConstantSlerp (Vector3 from, Vector3 to, float angle) {
float value = Mathf.Min(, angle / Vector3.Angle(from, to));
return Vector3.Slerp(from, to, value);
} }
ThirdPersonCamera.cs
using UnityEngine;
using System.Collections; /**
* @Author : www.xuanyusong.com
*/ public class ThirdPersonCamera : MonoBehaviour { public Transform cameraTransform;
private Transform _target; public float distance = 7.0f; public float height = 3.0f; public float angularSmoothLag = 0.3f;
public float angularMaxSpeed = 15.0f; public float heightSmoothLag = 0.3f; public float snapSmoothLag = 0.2f;
public float snapMaxSpeed = 720.0f; public float clampHeadPositionScreenSpace = 0.75f; public float lockCameraTimeout = 0.2f; private Vector3 headOffset = Vector3.zero;
private Vector3 centerOffset = Vector3.zero; private float heightVelocity = 0.0f;
private float angleVelocity = 0.0f;
private bool snap = false;
private ThirdPersonController controller;
private float targetHeight = 100000.0f; void Awake ()
{
if(!cameraTransform && Camera.main)
cameraTransform = Camera.main.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)
{
CharacterController characterController = (CharacterController)_target.collider;
centerOffset = characterController.bounds.center - _target.position;
headOffset = centerOffset;
headOffset.y = characterController.bounds.max.y - _target.position.y;
}
else
Debug.Log("Please assign a target to the camera that has a ThirdPersonController script attached."); Cut(_target, centerOffset);
} void DebugDrawStuff ()
{
Debug.DrawLine(_target.position, _target.position + headOffset); } float AngleDistance (float a , float b )
{
a = Mathf.Repeat(a, );
b = Mathf.Repeat(b, ); return Mathf.Abs(b - a);
} void Apply (Transform dummyTarget, Vector3 dummyCenter)
{
// Early out if we don't have a target
if (!controller)
return; Vector3 targetCenter = _target.position + centerOffset;
Vector3 targetHead = _target.position + headOffset; // DebugDrawStuff(); // Calculate the current & target rotation angles
float originalTargetAngle = _target.eulerAngles.y;
float currentAngle = cameraTransform.eulerAngles.y; // Adjust real target angle when camera is locked
float targetAngle = originalTargetAngle; // When pressing Fire2 (alt) the camera will snap to the target direction real quick.
// It will stop snapping when it reaches the target
if (Input.GetButton("Fire2"))
snap = true; if (snap)
{
// We are close to the target, so we can stop snapping now!
if (AngleDistance (currentAngle, originalTargetAngle) < 3.0)
snap = false; currentAngle = Mathf.SmoothDampAngle(currentAngle, targetAngle, ref angleVelocity, snapSmoothLag, snapMaxSpeed);
}
// Normal camera motion
else
{ if (controller.GetLockCameraTimer () < lockCameraTimeout)
{
targetAngle = currentAngle;
} // Lock the camera when moving backwards!
// * It is really confusing to do 180 degree spins when turning around.
if (AngleDistance (currentAngle, targetAngle) > && controller.IsMovingBackwards ())
targetAngle += ; currentAngle = Mathf.SmoothDampAngle(currentAngle, targetAngle, ref angleVelocity, angularSmoothLag, angularMaxSpeed);
} // When jumping don't move camera upwards but only down!
if (controller.IsJumping ())
{
// We'd be moving the camera upwards, do that only if it's really high
float newTargetHeight = targetCenter.y + height;
if (newTargetHeight < targetHeight || newTargetHeight - targetHeight > )
targetHeight = targetCenter.y + height;
}
// When walking always update the target height
else
{
targetHeight = targetCenter.y + height;
} // Damp the height
float currentHeight = cameraTransform.position.y;
currentHeight = Mathf.SmoothDamp (currentHeight, targetHeight, ref heightVelocity, heightSmoothLag); // Convert the angle into a rotation, by which we then reposition the camera
Quaternion currentRotation = Quaternion.Euler (, currentAngle, ); // Set the position of the camera on the x-z plane to:
// distance meters behind the target
cameraTransform.position = targetCenter;
cameraTransform.position += currentRotation * Vector3.back * distance; // Set the height of the camera
cameraTransform.position = new Vector3(cameraTransform.position.x,currentHeight,cameraTransform.position.z); // Always look at the target
SetUpRotation(targetCenter, targetHead);
} void LateUpdate () {
Apply (transform, Vector3.zero);
} void Cut (Transform dummyTarget , Vector3 dummyCenter)
{
float oldHeightSmooth = heightSmoothLag;
float oldSnapMaxSpeed = snapMaxSpeed;
float oldSnapSmooth = snapSmoothLag; snapMaxSpeed = ;
snapSmoothLag = 0.001f;
heightSmoothLag = 0.001f; snap = true;
Apply (transform, Vector3.zero); heightSmoothLag = oldHeightSmooth;
snapMaxSpeed = oldSnapMaxSpeed;
snapSmoothLag = oldSnapSmooth;
} void SetUpRotation (Vector3 centerPos,Vector3 headPos)
{
// Now it's getting hairy. The devil is in the details here, the big issue is jumping of course.
// * When jumping up and down we don't want to center the guy in screen space.
// This is important to give a feel for how high you jump and avoiding large camera movements.
//
// * At the same time we dont want him to ever go out of screen and we want all rotations to be totally smooth.
//
// So here is what we will do:
//
// 1. We first find the rotation around the y axis. Thus he is always centered on the y-axis
// 2. When grounded we make him be centered
// 3. When jumping we keep the camera rotation but rotate the camera to get him back into view if his head is above some threshold
// 4. When landing we smoothly interpolate towards centering him on screen
Vector3 cameraPos = cameraTransform.position;
Vector3 offsetToCenter = centerPos - cameraPos; // Generate base rotation only around y-axis
Quaternion yRotation = Quaternion.LookRotation(new Vector3(offsetToCenter.x, , offsetToCenter.z)); Vector3 relativeOffset = Vector3.forward * distance + Vector3.down * height;
cameraTransform.rotation = yRotation * Quaternion.LookRotation(relativeOffset); // Calculate the projected center position and top position in world space
Ray centerRay = cameraTransform.camera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 1f));
Ray topRay = cameraTransform.camera.ViewportPointToRay(new Vector3(0.5f, clampHeadPositionScreenSpace, 1f)); Vector3 centerRayPos = centerRay.GetPoint(distance);
Vector3 topRayPos = topRay.GetPoint(distance); float centerToTopAngle = Vector3.Angle(centerRay.direction, topRay.direction); float heightToAngle = centerToTopAngle / (centerRayPos.y - topRayPos.y); float extraLookAngle = heightToAngle * (centerRayPos.y - centerPos.y);
if (extraLookAngle < centerToTopAngle)
{
extraLookAngle = ;
}
else
{
extraLookAngle = extraLookAngle - centerToTopAngle;
cameraTransform.rotation *= Quaternion.Euler(-extraLookAngle, , );
}
} Vector3 GetCenterOffset ()
{
return centerOffset;
} }
ThirdPersonController.cs
using UnityEngine;
using System.Collections; /**
* @Author : www.xuanyusong.com
*/ [RequireComponent(typeof(CharacterController))] public class ThirdPersonController : MonoBehaviour { public AnimationClip idleAnimation ;
public AnimationClip walkAnimation ;
public AnimationClip runAnimation ;
public AnimationClip jumpPoseAnimation; public float walkMaxAnimationSpeed = 0.75f;
public float trotMaxAnimationSpeed = 1.0f;
public float runMaxAnimationSpeed = 1.0f;
public float jumpAnimationSpeed = 1.15f;
public float landAnimationSpeed = 1.0f; private Animation _animation; enum CharacterState
{
Idle = ,
Walking = ,
Trotting = ,
Running = ,
Jumping = ,
} private CharacterState _characterState; // The speed when walking
float walkSpeed = 2.0f;
// after trotAfterSeconds of walking we trot with trotSpeed
float trotSpeed = 4.0f;
// when pressing "Fire3" button (cmd) we start running
float runSpeed = 6.0f; float inAirControlAcceleration = 3.0f; // How high do we jump when pressing jump and letting go immediately
float jumpHeight = 0.5f; // The gravity for the character
float gravity = 20.0f;
// The gravity in controlled descent mode
float speedSmoothing = 10.0f;
float rotateSpeed = 500.0f;
float trotAfterSeconds = 3.0f; bool canJump = true; private float jumpRepeatTime = 0.05f;
private float jumpTimeout = 0.15f;
private float groundedTimeout = 0.25f; // The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
private float lockCameraTimer = 0.0f; // The current move direction in x-z
private Vector3 moveDirection = Vector3.zero;
// The current vertical speed
private float verticalSpeed = 0.0f;
// The current x-z move speed
private float moveSpeed = 0.0f; // The last collision flags returned from controller.Move
private CollisionFlags collisionFlags; // Are we jumping? (Initiated with jump button and not grounded yet)
private bool jumping = false;
private bool jumpingReachedApex = false; // Are we moving backwards (This locks the camera to not do a 180 degree spin)
private bool movingBack = false;
// Is the user pressing any keys?
private bool isMoving = false;
// When did the user start walking (Used for going into trot after a while)
private float walkTimeStart = 0.0f;
// Last time the jump button was clicked down
private float lastJumpButtonTime = -10.0f;
// Last time we performed a jump
private float lastJumpTime = -1.0f; // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
private float lastJumpStartHeight = 0.0f; private Vector3 inAirVelocity = Vector3.zero; private float lastGroundedTime = 0.0f; private bool isControllable = true; void 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.");
} } void UpdateSmoothedMovementDirection ()
{
Transform cameraTransform = Camera.main.transform;
bool grounded = IsGrounded(); // Forward vector relative to the camera along the x-z plane
Vector3 forward = cameraTransform.TransformDirection(Vector3.forward);
forward.y = ;
forward = forward.normalized; // Right vector relative to the camera
// Always orthogonal to the forward vector
Vector3 right = new Vector3(forward.z, , -forward.x); float v = Input.GetAxisRaw("Vertical");
float h = Input.GetAxisRaw("Horizontal"); // Are we moving backwards or looking backwards
if (v < -0.2f)
movingBack = true;
else
movingBack = false; bool wasMoving = isMoving;
isMoving = Mathf.Abs (h) > 0.1f || Mathf.Abs (v) > 0.1f; // Target direction relative to the camera
Vector3 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.0f; // 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.9f && grounded)
{
moveDirection = targetDirection.normalized;
}
// Otherwise smoothly turn towards it
else
{
moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, ); moveDirection = moveDirection.normalized;
}
} // Smooth the speed based on the current target direction
float 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
float targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0f); _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.3f)
walkTimeStart = Time.time;
}
// In air controls
else
{
// Lock camera while in air
if (jumping)
lockCameraTimer = 0.0f; if (isMoving)
inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
} } void 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);
}
}
} void ApplyGravity ()
{
if (isControllable) // don't move player at all if not controllable.
{
// Apply gravity
bool jumpButton = Input.GetButton("Jump"); // When we reach the apex of the jump we send out a message
if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0f)
{
jumpingReachedApex = true;
SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
} if (IsGrounded ())
verticalSpeed = 0.0f;
else
verticalSpeed -= gravity * Time.deltaTime;
}
} 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( * targetJumpHeight * gravity);
} void DidJump ()
{
jumping = true;
jumpingReachedApex = false;
lastJumpTime = Time.time;
lastJumpStartHeight = transform.position.y;
lastJumpButtonTime = -; _characterState = CharacterState.Jumping;
} void Update() { if (!isControllable)
{
// kill all inputs if not controllable.
Input.ResetInputAxes();
} if (Input.GetButtonDown ("Jump"))
{
lastJumpButtonTime = Time.time;
} UpdateSmoothedMovementDirection(); // Apply gravity
// - extra power jump modifies gravity
// - controlledDescent mode modifies gravity
ApplyGravity (); // Apply jumping logic
ApplyJumping (); // Calculate actual motion
Vector3 movement = moveDirection * moveSpeed + new Vector3 (, verticalSpeed, ) + inAirVelocity;
movement *= Time.deltaTime; // Move the controller
CharacterController controller = GetComponent<CharacterController>();
collisionFlags = controller.Move(movement); // 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.1f) {
_animation.CrossFade(idleAnimation.name);
}
else
{
if(_characterState == CharacterState.Running) {
_animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0f, runMaxAnimationSpeed);
_animation.CrossFade(runAnimation.name);
}
else if(_characterState == CharacterState.Trotting) {
_animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0f, trotMaxAnimationSpeed);
_animation.CrossFade(walkAnimation.name);
}
else if(_characterState == CharacterState.Walking) {
_animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0f, walkMaxAnimationSpeed);
_animation.CrossFade(walkAnimation.name);
} }
}
}
// ANIMATION sector // Set rotation to the move direction
if (IsGrounded())
{ transform.rotation = Quaternion.LookRotation(moveDirection); }
else
{
Vector3 xzMove = movement;
xzMove.y = ;
if (xzMove.sqrMagnitude > 0.001f)
{
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);
}
}
} void OnControllerColliderHit (ControllerColliderHit hit )
{
// Debug.DrawRay(hit.point, hit.normal);
if (hit.moveDirection.y > 0.01f)
return;
} float GetSpeed () {
return moveSpeed;
} public bool IsJumping () {
return jumping;
} bool IsGrounded () {
return (collisionFlags & CollisionFlags.CollidedBelow) != ;
} Vector3 GetDirection () {
return moveDirection;
} public bool IsMovingBackwards () {
return movingBack;
} public float GetLockCameraTimer ()
{
return lockCameraTimer;
} bool IsMoving ()
{
return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5f;
} bool HasJumpReachedApex ()
{
return jumpingReachedApex;
} bool IsGroundedWithTimeout ()
{
return lastGroundedTime + groundedTimeout > Time.time;
} void Reset ()
{
gameObject.tag = "Player";
} }