Third Person Camera

I am making a third person game i can do it but just one thing the camera i want to make like a third person shooter can anyone help???

Make the camera a children of your player, or make a script that make your camera chase the player(a bit more complicated).

I recomend the first, but if you want the camera not to pass through the walls, well, you’ll need to do some research. I recomend Google and YouTube.

If you make the camera as a child and set the position of it so it can be at the back of your player, and then set the rotations (all of this through Inspector tab) then you’ll have it. Hope I’ve helped.

You’re looking at adding MouseLook script to:

  1. Player (X axis)
  2. 3rd view camera (Y axis)
  3. Smooth Follow script

Here’s for mouse

using UnityEngine;
using System.Collections;

public class TPSCamera : MonoBehaviour {
/* These variables are what tell the camera how its going to function by
* setting the viewing target, collision layers, and other properties
* such as distance and viewing angles */
public Transform viewTarget, aimPoint;
public LayerMask collisionLayers;
public float distance = 2.5f;
public float height = 1.75f;
public float offset = 0.65f;
public float collisionOffset = 0.3f;
public float horizontalRotationSpeed = 250.0f;
public static float turnSpeed = 5f;
public float verticalRotationSpeed = 150.0f;
public float rotationDampening = 0.75f;
public float minVerticalAngle = -60.0f;
public float maxVerticalAngle = 60.0f;
public bool rotatePlayerWithCamera = true;
public bool invertPlayerAim = false;

/* These variables are meant to store values given by the script and
 * not the user */
private float h, v;
private Vector3 newPosition;
private Quaternion newRotation, smoothRotation;
private Transform cameraTransform;

/* This is where we initialize our script */
void Start () {
	Initialize ();
}

/* This is where we set our private variables, check for null errors,
 * and anything else that needs to be called once during startup */
void Initialize () {
	h = this.transform.eulerAngles.x;
	v = this.transform.eulerAngles.y;
	
	cameraTransform = this.transform;
			
	NullErrorCheck ();
}

/* We check for null errors or warnings and notify the user to fix them */
void NullErrorCheck () {
	if (!viewTarget) {
		Debug.LogError("Please make sure to assign a view target!");
		Debug.Break ();
	}
	if (collisionLayers == 0) {
		Debug.LogWarning("Make sure to set the collision layers to the layers the camera should collide with!");
	}
}

void Update(){
horizontalRotationSpeed = turnSpeed;
}
void LateUpdate () {
if (!viewTarget)
return;

	/* We check that the game isn't paused and lock the cursor */
	if (Time.timeScale > 0.0f)
		Screen.lockCursor = true;

	h += Input.GetAxis ("Mouse X") * (horizontalRotationSpeed * Time.deltaTime);
	v -= Input.GetAxis ("Mouse Y") * (verticalRotationSpeed * Time.deltaTime);

	h = ClampAngle (h, -360.0f, 360.0f);
	v = ClampAngle (v, minVerticalAngle, maxVerticalAngle);

	newRotation = Quaternion.Euler(v, h, 0.0f);

	/* We smooth the camera rotation using a growth function for a nicer viewing effect */
	smoothRotation = Quaternion.Slerp (smoothRotation, newRotation, TimeSignature((1 / rotationDampening) * 100.0f));
	
	newPosition = viewTarget.position;
	newPosition += smoothRotation * new Vector3 (offset, height, -distance);

	/* This calls our function to avoid camera clipping */
	CheckSphere ();

	smoothRotation.eulerAngles = new Vector3 (smoothRotation.eulerAngles.x, smoothRotation.eulerAngles.y, 0.0f);
	
	cameraTransform.position = newPosition;
	cameraTransform.rotation = smoothRotation;

	Vector3 newTargetRot = new Vector3 (0.0f, cameraTransform.eulerAngles.y, 0.0f);

	if (rotatePlayerWithCamera) {
		/* We set our player's rotation to the cameras y rotation */
		viewTarget.rotation = Quaternion.Euler (newTargetRot);
		//Debug.Log ("FIXED");
	}

	/* We set the players aim rotation to the cameras x rotation */
	newTargetRot = aimPoint.eulerAngles;
	if (invertPlayerAim)
		newTargetRot.x = (cameraTransform.eulerAngles.x);
	else 
		newTargetRot.x = -(cameraTransform.eulerAngles.x);
	aimPoint.rotation = Quaternion.Euler (newTargetRot);
}

/* This is where the camera checks for a collsion hit within a specified radius,
 * and then moves the camera above the location it hit with an offset value */
void CheckSphere () {
	/* Add height to our spherecast origin */
	Vector3 tmpVect = viewTarget.position;
	tmpVect.x += offset;
	tmpVect.y += height;
	
	RaycastHit hit;
	
	/* Get the direction from the camera position to the origin */
	Vector3 dir = (newPosition - tmpVect).normalized;
	
	/* Check a radius for collision hits and then set the new position for
	 * the camera */
	if(Physics.SphereCast(tmpVect, 0.3f, dir, out hit, distance, collisionLayers)) {
		newPosition = hit.point + (hit.normal * collisionOffset);
	}
}

/* Keeps the angles values within their specificed minimum and maximum
 * inputs while at the same time putting the values back to 0 if they 
 * go outside of the 360 degree range */
private float ClampAngle (float angle, float min, float max) {
	if(angle < -360)
		angle += 360;
	
	if(angle > 360) 
		angle -= 360;
	
	return Mathf.Clamp (angle, min, max);
}

/* This is our custom logistic growth time signature with speed as input */
private float TimeSignature(float speed) {
	return 1.0f / (1.0f + 80.0f * Mathf.Exp(-speed * 0.02f));
}

}