Unity camera follows player script

Making the camera following the player is quite straight forward.

Add this script to your main camera. Drag the reference of the player object to the script and then you are done.

You can change the values in the Vector 3 depending on how far you want the camera to be from the player.

using UnityEngine;

public class Follow_player : MonoBehaviour {

    public Transform player;

    // Update is called once per frame
    void Update () {
        transform.position = player.transform.position + new Vector3(0, 1, -5);
    }
}

This will always follow the player from the same direction, and if the player rotates it will still stay the same. This may be good for top-down or side-scrolling view, but the camera setup seems to be more fitting for 3rd person, in which case you'd want to rotate the camera when the player turns.

The easiest way to do this is actually not with code alone, simply make the camera a child of the player object, that way its position relative to the player will always stay the same!

If you do want to do it through code, you can change the code to be like this:

void Update()
{
    Vector3 back = -player.transform.forward;
    back.y = 0.5f; // this determines how high. Increase for higher view angle.
    transform.position = player.transform.position - back * distance;

    transform.forward = player.transform.position - transform.position;
}

You get the direction of the back of the player (opposite of transform's forward). Then you increase the height a little so the angle will be a bit from above like in your example. Last you set the camera's position to be the player's position and add the back direction multiplied by the distance. That will place the camera behind the player.

You also need to rotate the camera so it points at the player, and that's the last line - setting the camera's forward direction to point at the player.

Follows player in the back constantly when the player rotates, no parenting needed, with smoothing.

Piece of Knowledges:

• Apparently, Quaternion * Vector3 is going to rotate the point of the Vector3 around the origin of the Vector3 by the angle of the Quaternion
• The Lerp method in Vector3 and Quaternion stand for linear interpolation, where the first parameter gets closer to the second parameter by the amount of third parameter each frame.

using UnityEngine;

public class CameraFollow : MonoBehaviour

{
    public Transform target;
    public float smoothSpeed = 0.125f;
    public Vector3 locationOffset;
    public Vector3 rotationOffset;

    void FixedUpdate()
    {
        Vector3 desiredPosition = target.position + target.rotation * locationOffset;
        Vector3 smoothedPosition = Vector3.Lerp(transform.position, desiredPosition, smoothSpeed);
        transform.position = smoothedPosition;

        Quaternion desiredrotation = target.rotation * Quaternion.Euler(rotationOffset);
        Quaternion smoothedrotation = Quaternion.Lerp(transform.rotation, desiredrotation, smoothSpeed);
        transform.rotation = smoothedrotation;
    }
}

Here is just another option. I always find it easier to have the variables which are populated in the inspector so you can adjust it and fine tune it as needed.

public GameObject player;
[SerializeField]
private float xAxis, yAxis, zAxis;

private void Update()
{
    transform.position = new Vector3(player.transform.position.x + xAxis, player.transform.position.y + yAxis, player.transform.position.z + zAxis);
}