Circle strafing/Z-Targeting

This was something that I always wanted to do but could never manage to emulate.

alt text

Pretty much from what I can see, the character’s movement vector is modified to orbit around the target, while assuring that the camera should have the target at all times, but I’m not sure how to actual modify the movement vector to do so. From what I researched, it would require the character to move in a diagonal like fashion when locked on to a target.

This is all I have so far in my Late Update. At this point, the character faces the target, but the camera doesn’t stay directly behind the player.

void  LateUpdate ()
{
    if (target) 
    {
        xSmooth = Mathf.SmoothDamp(xSmooth, x, ref xVelocity, smoothTime);
        ySmooth = Mathf.SmoothDamp(ySmooth, y, ref yVelocity, smoothTime);
 
        ClampAngle(ySmooth, yMinLimit, yMaxLimit);

        Quaternion rotation = Quaternion.Euler(ySmooth, xSmooth, 0);
 
       // posSmooth = Vector3.SmoothDamp(posSmooth,target.position,posVelocity,smoothTime);
        posSmooth = (target.position + player.position)/2; // no follow smoothing

        var playerLook = new Vector3(target.position.x, player.position.y, target.position.z);
        player.LookAt(playerLook);


        transform.rotation = rotation;

        transform.position = rotation * new Vector3(0.0f, 0.0f, -distance) + posSmooth;
        transform.LookAt((target.position + player.position)/2 + new Vector3(0,0,3));
    }
}

Any help would be appreciated.

I managed to make a similar camera by merging and modifying some of the basic camera scripts provided by Unity:

using UnityEngine;
using System.Collections;

public class Orbit : MonoBehaviour
{
    public Transform target, player;
    float distance = 10.0f;

    float xSpeed = 1;
    float ySpeed = 1;

    float yMinLimit = -20;
    float yMaxLimit = 80;

    private float x = 0.0f;
    private float y = 0.0f;


    float smoothTime = 0.3f;

    private float xSmooth = 0.0f;
    private float ySmooth = 0.0f;
    private float xVelocity = 0.0f;
    private float yVelocity = 0.0f;

    private Vector3 posSmooth = Vector3.zero;
    private Vector3 posVelocity = Vector3.zero;

    public float zOffset = 3;


    //@script AddComponentMenu("Camera-Control/Mouse Orbit smoothed")

    void Start()
    {
        Vector3 angles = transform.eulerAngles;
        x = angles.y;
        y = angles.x;

        // Make the rigid body not change rotation
        if (rigidbody)
            rigidbody.freezeRotation = true;
    }

    // The distance in the x-z plane to the target
    // the height we want the camera to be above the target
    public float height = 5.0f;
    // How much we 
    public float heightDamping = 2.0f;
    public float rotationDamping = 3.0f;


    void LateUpdate()
    {
        if (target)
        {
            xSmooth = Mathf.SmoothDamp(xSmooth, x, ref xVelocity, smoothTime);
            ySmooth = Mathf.SmoothDamp(ySmooth, y, ref yVelocity, smoothTime);

            ClampAngle(ySmooth, yMinLimit, yMaxLimit);

            posSmooth = (target.position + player.position) / 2; // no follow smoothing

            var playerLook = new Vector3(target.position.x, player.position.y, target.position.z);
            player.LookAt(playerLook);

            transform.LookAt(player.position);

            // Calculate the current rotation angles
            var wantedRotationAngle = player.eulerAngles.y;
            var wantedHeight = player.position.y + 2;

            var currentRotationAngle = transform.eulerAngles.y;
            var currentHeight = transform.position.y;

            // Damp the rotation around the y-axis
            currentRotationAngle = Mathf.LerpAngle(currentRotationAngle, wantedRotationAngle, rotationDamping * Time.deltaTime);

            // Damp the height
            currentHeight = Mathf.Lerp(currentHeight, wantedHeight, heightDamping * Time.deltaTime);

            // Convert the angle into a rotation
            var currentRotation = Quaternion.Euler(0, currentRotationAngle, 0);

            // Set the position of the camera on the x-z plane to:
            // distance meters behind the target
            transform.position = player.position;
            transform.position -= currentRotation * Vector3.forward * distance;

            // Set the height of the camera
            transform.position = new Vector3(transform.position.x, height, transform.position.z);

            // Always look at the target
            transform.LookAt(player);

        }
    }

    static void ClampAngle(float angle, float min, float max)
    {
        if (angle < -360)
            angle += 360;
        if (angle > 360)
            angle -= 360;
        //return Mathf.Clamp (angle, min, max);
    }