GathererOfSouls/Assets/Scripts/CameraController.cs

using UnityEngine;
using UnityEngine.InputSystem;

public class CameraController : MonoBehaviour
{
    [Header("Movement Settings")]
    public float moveSpeed = 10f;
    public float fastMoveSpeed = 20f;
    public float mouseSensitivity = 2f;

    [Header("Zoom Settings")]
    public float zoomSpeed = 5f;
    public float minZoom = 5f;
    public float maxZoom = 20f;

    [Header("Boundaries")]
    public bool useBoundaries = true;
    public Vector2 mapBounds = new Vector2(50f, 50f);

    [Header("Mouse Controls")]
    public bool enableMouseDrag = true;
    public bool invertMouseY = false;

    private Camera playerCamera;
    private Vector2 lastMousePosition;
    private bool isMouseDragging = false;
    private float currentZoom;

    void Start()
    {
        playerCamera = GetComponent<Camera>();
        if (playerCamera == null)
        {
            Debug.LogError("CameraController requires a Camera component!");
            return;
        }

        currentZoom = playerCamera.orthographicSize;
    }

    void Update()
    {
        HandleKeyboardMovement();
        HandleMouseControls();
        HandleZoom();
        EnforceBoundaries();
    }

    void HandleKeyboardMovement()
    {
        Vector3 moveDirection = Vector3.zero;

        // WASD movement
        var keyboard = Keyboard.current;
        if (keyboard.wKey.isPressed || keyboard.upArrowKey.isPressed)
            moveDirection += Vector3.forward;
        if (keyboard.sKey.isPressed || keyboard.downArrowKey.isPressed)
            moveDirection += Vector3.back;
        if (keyboard.aKey.isPressed || keyboard.leftArrowKey.isPressed)
            moveDirection += Vector3.left;
        if (keyboard.dKey.isPressed || keyboard.rightArrowKey.isPressed)
            moveDirection += Vector3.right;

        // Apply movement
        if (moveDirection != Vector3.zero)
        {
            float currentMoveSpeed = keyboard.leftShiftKey.isPressed ? fastMoveSpeed : moveSpeed;

            // Adjust speed based on zoom level (more zoomed out = faster movement)
            float zoomSpeedMultiplier = currentZoom / 10f;
            currentMoveSpeed *= zoomSpeedMultiplier;

            transform.Translate(moveDirection.normalized * currentMoveSpeed * Time.deltaTime, Space.World);
        }
    }

    void HandleMouseControls()
    {
        if (!enableMouseDrag) return;

        // Middle mouse button or right mouse button for dragging
        var mouse = Mouse.current;
        var keyboard = Keyboard.current;
        if (mouse.middleButton.wasPressedThisFrame || (mouse.rightButton.wasPressedThisFrame && keyboard.leftCtrlKey.isPressed))
        {
            lastMousePosition = mouse.position.ReadValue();
            isMouseDragging = true;
        }

        if (mouse.middleButton.wasReleasedThisFrame || mouse.rightButton.wasReleasedThisFrame)
        {
            isMouseDragging = false;
        }

        if (isMouseDragging)
        {
            Vector2 mouseDelta = mouse.position.ReadValue() - lastMousePosition;

            // Convert mouse movement to world movement
            Vector3 worldDelta = playerCamera.ScreenToWorldPoint(new Vector3(mouseDelta.x, mouseDelta.y, playerCamera.nearClipPlane));
            worldDelta = transform.TransformDirection(worldDelta);

            // Invert movement (moving mouse right should move camera left)
            Vector3 moveVector = new Vector3(-worldDelta.x, 0, invertMouseY ? worldDelta.z : -worldDelta.z);

            // Scale by zoom level and sensitivity
            float zoomSpeedMultiplier = currentZoom / 10f;
            moveVector *= mouseSensitivity * zoomSpeedMultiplier * 0.1f;

            transform.Translate(moveVector, Space.World);

            lastMousePosition = mouse.position.ReadValue();
        }
    }

    void HandleZoom()
    {
        var mouse = Mouse.current;
        var keyboard = Keyboard.current;
        float scrollInput = mouse.scroll.ReadValue().y / 120f; // Convert to old Input.GetAxis scale

        if (scrollInput != 0)
        {
            currentZoom -= scrollInput * zoomSpeed;
            currentZoom = Mathf.Clamp(currentZoom, minZoom, maxZoom);

            if (playerCamera.orthographic)
            {
                playerCamera.orthographicSize = currentZoom;
            }
            else
            {
                // For perspective camera, adjust distance from ground
                Vector3 pos = transform.position;
                pos.y = currentZoom;
                transform.position = pos;
            }
        }

        // Keyboard zoom controls
        if (keyboard.equalsKey.isPressed || keyboard.numpadPlusKey.isPressed)
        {
            currentZoom -= zoomSpeed * Time.deltaTime;
            currentZoom = Mathf.Clamp(currentZoom, minZoom, maxZoom);
            playerCamera.orthographicSize = currentZoom;
        }

        if (keyboard.minusKey.isPressed || keyboard.numpadMinusKey.isPressed)
        {
            currentZoom += zoomSpeed * Time.deltaTime;
            currentZoom = Mathf.Clamp(currentZoom, minZoom, maxZoom);
            playerCamera.orthographicSize = currentZoom;
        }
    }

    void EnforceBoundaries()
    {
        if (!useBoundaries) return;

        Vector3 pos = transform.position;

        // Clamp camera position within map bounds
        pos.x = Mathf.Clamp(pos.x, -mapBounds.x, mapBounds.x);
        pos.z = Mathf.Clamp(pos.z, -mapBounds.y, mapBounds.y);

        transform.position = pos;
    }

    public void FocusOnPosition(Vector3 worldPosition)
    {
        Vector3 newPosition = worldPosition;
        newPosition.y = transform.position.y; // Keep current height
        transform.position = newPosition;
    }

    public void SetZoom(float zoom)
    {
        currentZoom = Mathf.Clamp(zoom, minZoom, maxZoom);
        playerCamera.orthographicSize = currentZoom;
    }

    public void ResetToDefault()
    {
        transform.position = new Vector3(0, 10, 0);
        transform.rotation = Quaternion.Euler(45, 0, 0);
        SetZoom(15f);
    }

    void OnDrawGizmosSelected()
    {
        if (useBoundaries)
        {
            // Draw map boundaries
            Gizmos.color = Color.red;
            Vector3 center = Vector3.zero;
            Vector3 size = new Vector3(mapBounds.x * 2, 1, mapBounds.y * 2);
            Gizmos.DrawWireCube(center, size);
        }
    }
}