Third person WOW like camera

I will post the WOW camera script at the bottom, but for now I'll explain the hierarchy.

The first thing you need of course is Ethan a.k.a the standard third person controller prefab. Attach a camera to his prefab and name it Main Camera and also don't forget to set its tag to MainCamera.



Then attach the WOW camera script to the Main Camera as a component.



It will throw an error in the ThirdPersonCharacter.cs script, that there was a null reference somewhere. If that happens, just open the script and edit the Start() {...} function to Awake() {...} and there won't be any errors.

It doesn't seem a big kind of a deal, but I'm sure for a lot of people this is a pretty easy way to have a good type of camera for your 3rd person RPG.

Here's the WOW camera script, what you will need for this:

 using UnityEngine;
 using System.Collections;
 
 public class WowCamera : MonoBehaviour
 {
     public Transform target;
 
     public float targetHeight = 1.7f;
     public float distance = 5.0f;
     public float offsetFromWall = 0.1f;
 
     public float maxDistance = 20;
     public float minDistance = .6f;
     public float speedDistance = 5;
 
     public float xSpeed = 200.0f;
     public float ySpeed = 200.0f;
 
     public int yMinLimit = -40;
     public int yMaxLimit = 80;
 
     public int zoomRate = 40;
 
     public float rotationDampening = 3.0f;
     public float zoomDampening = 5.0f;
 
     public LayerMask collisionLayers = -1;
 
     private float xDeg = 0.0f;
     private float yDeg = 0.0f;
     private float currentDistance;
     private float desiredDistance;
     private float correctedDistance;
 
     void Start ()
     {
         Vector3 angles = transform.eulerAngles;
         xDeg = angles.x;
         yDeg = angles.y;
 
         currentDistance = distance;
         desiredDistance = distance;
         correctedDistance = distance;
 
         // Make the rigid body not change rotation
         if (this.gameObject.GetComponent<Rigidbody>())
             this.gameObject.GetComponent<Rigidbody>().freezeRotation = true;
     }
 
     /**
      * Camera logic on LateUpdate to only update after all character movement logic has been handled.
      */
     void LateUpdate ()
     {
         Vector3 vTargetOffset;
 
         // Don't do anything if target is not defined
         if (!target)
             return;
 
         // If either mouse buttons are down, let the mouse govern camera position
         if (GUIUtility.hotControl == 0) {
             if (Input.GetMouseButton(0) || Input.GetMouseButton(1))
             {
                 xDeg += Input.GetAxis ("Mouse X") * xSpeed * 0.02f;
                 yDeg -= Input.GetAxis ("Mouse Y") * ySpeed * 0.02f;
             }
 
             // otherwise, ease behind the target if any of the directional keys are pressed
             else if (Input.GetAxis("Vertical") != 0 || Input.GetAxis("Horizontal") != 0)
             {
                 float targetRotationAngle = target.eulerAngles.y;
                 float currentRotationAngle = transform.eulerAngles.y;
                 xDeg = Mathf.LerpAngle (currentRotationAngle, targetRotationAngle, rotationDampening * Time.deltaTime);
             }
         }
 
 
         // calculate the desired distance
         desiredDistance -= Input.GetAxis ("Mouse ScrollWheel") * Time.deltaTime * zoomRate * Mathf.Abs (desiredDistance) * speedDistance;
         desiredDistance = Mathf.Clamp (desiredDistance, minDistance, maxDistance);
 
         yDeg = ClampAngle(yDeg, yMinLimit, yMaxLimit);
 
         // set camera rotation
         Quaternion rotation = Quaternion.Euler(yDeg, xDeg, 0);
         correctedDistance = desiredDistance;
 
         // calculate desired camera position
         vTargetOffset = new Vector3 (0, -targetHeight, 0);
         Vector3 position = target.position - (rotation * Vector3.forward * desiredDistance + vTargetOffset);
 
         // check for collision using the true target's desired registration point as set by user using height
         RaycastHit collisionHit;
         Vector3 trueTargetPosition = new Vector3(target.position.x, target.position.y, target.position.z) - vTargetOffset;
 
         // if there was a collision, correct the camera position and calculate the corrected distance
         bool isCorrected = false;
         if (Physics.Linecast (trueTargetPosition, position, out collisionHit, collisionLayers.value))
         {
             // calculate the distance from the original estimated position to the collision location,
             // subtracting out a safety "offset" distance from the object we hit.  The offset will help
             // keep the camera from being right on top of the surface we hit, which usually shows up as
             // the surface geometry getting partially clipped by the camera's front clipping plane.
             correctedDistance = Vector3.Distance (trueTargetPosition, collisionHit.point) - offsetFromWall;
             isCorrected = true;
         }
 
         // For smoothing, lerp distance only if either distance wasn't corrected, or correctedDistance is more than currentDistance
         currentDistance = !isCorrected || correctedDistance > currentDistance ? Mathf.Lerp (currentDistance, correctedDistance, Time.deltaTime * zoomDampening) : correctedDistance;
 
         // keep within legal limits
         currentDistance = Mathf.Clamp (currentDistance, minDistance, maxDistance);
 
         // recalculate position based on the new currentDistance
         position = target.position - (rotation * Vector3.forward * currentDistance + vTargetOffset);
 
         transform.rotation = rotation;
         transform.position = position;
     }
 
     private static float ClampAngle (float angle, float min, float max)
     {
         if (angle < -360)
             angle += 360;
         if (angle > 360)
             angle -= 360;
         return Mathf.Clamp (angle, min, max);
     }
 }