In Unity, how to control the horizontal and vertical movement, as well as rotation and panning, of a top-down camera (45-degree angle perspective)?

I need a 3D camera control effect like the game 'Frostpunk'. I don't know how to use Euler angles or quaternions. The most important thing is that everything becomes unpredictable when the camera's Rotation.Y changes. I need a formula or a piece of code to solve this problem.

I can now move correctly up, down, left, and right in world coordinates, but problems arise when the local coordinate system is different from the world coordinate system.

Controlling a top-down camera in Unity can be a bit tricky, especially if you're new to working with Euler angles or quaternions. However, with a bit of math and some Unity code, you can achieve the desired camera behavior.

Here is an example script that should help you control the horizontal and vertical movement, as well as rotation and panning of a top-down camera:

Example:

using UnityEngine;

public class TopDownCameraController : MonoBehaviour
{
    public Transform target; // The object the camera will follow
    public float distance = 10f; // The distance between the camera and the target
    public float height = 10f; // The height of the camera above the target
    public float rotationSpeed = 10f; // The speed at which the camera rotates

    private float currentRotation = 0f; // The current rotation of the camera

    void LateUpdate()
    {
        // Get the horizontal and vertical inputs
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        // Calculate the target position based on the inputs
        Vector3 targetPosition = target.position + new Vector3(horizontalInput, 0f, verticalInput) * distance;

        // Set the camera's position to the target position plus the height
        transform.position = new Vector3(targetPosition.x, targetPosition.y + height, targetPosition.z);

        // Calculate the rotation based on the inputs and the rotation speed
        currentRotation += Input.GetAxis("Rotation") * rotationSpeed * Time.deltaTime;

        // Set the camera's rotation to the current rotation
        transform.rotation = Quaternion.Euler(45f, currentRotation, 0f);

        // Calculate the panning based on the inputs
        float panInput = Input.GetAxis("Pan");

        // Move the camera's position horizontally based on the panning input
        transform.position += transform.right * panInput;
    }
}

This script assumes that you have a target object that the camera will follow, and that the camera is initially positioned directly above the target with a 45-degree angle perspective. The script uses the LateUpdate() function to ensure that the camera is positioned after the target has moved.

The distance, height, and rotationSpeed variables control the distance between the camera and the target, the height of the camera above the target, and the speed at which the camera rotates, respectively. You can adjust these variables to achieve the desired camera behavior.

The script uses the GetAxis() function to get the horizontal, vertical, rotation, and pan inputs from the user. These inputs are used to calculate the target position, the rotation, and the panning of the camera.

The currentRotation variable keeps track of the current rotation of the camera, which is updated based on the rotation input and the rotation speed.

Finally, the script moves the camera's position horizontally based on the panning input.

I understand your frustration , camera control can be tricky in 3D space.This script uses Euler angles to control the camera, so you don't need to worry about quaternions.

public class CameraController : MonoBehaviour
{
    public Transform target;
    public float distance = 5.0f;
    public float height = 2.0f;
    public float rotationDamping = 3.0f;
    public float heightDamping = 2.0f;
    public float zoomDamping = 2.0f;
    public float minZoomDistance = 2.0f;
    public float maxZoomDistance = 10.0f;

    private void LateUpdate()
    {
        if (!target)
            return;

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

        float desiredRotationAngle = target.eulerAngles.y;
        float desiredHeight = target.position.y + height;

        currentHeight = Mathf.Lerp(currentHeight, desiredHeight, heightDamping * Time.deltaTime);
        currentRotationAngle = Mathf.LerpAngle(currentRotationAngle, desiredRotationAngle, rotationDamping * Time.deltaTime);

        Quaternion currentRotation = Quaternion.Euler(0, currentRotationAngle, 0);

        float desiredDistance = Mathf.Clamp(distance - Input.GetAxis("Mouse ScrollWheel") * zoomDamping, minZoomDistance, maxZoomDistance);
        Vector3 zoomVector = new Vector3(0, 0, -desiredDistance);
        Vector3 position = target.position + (currentRotation * zoomVector);

        transform.position = Vector3.Lerp(transform.position, position, Time.deltaTime * zoomDamping);
        transform.position = new Vector3(transform.position.x, currentHeight, transform.position.z);

        transform.LookAt(target);
    }
}

** You may use this script to attach it to the camera object in your scene