Basic Jump

using UnityEngine;

/// <summary>
/// BASIC JUMP FPS - First-person jump with integrated mouselook
/// VG101 Code Bank - Requires InputReader from Input Setup
/// Complete FPS controller with jumping
/// </summary>
[RequireComponent(typeof(CharacterController))]
public class BasicJumpFPS : MonoBehaviour
{
    [Header("Jump Feel")]
    [Tooltip("How hard we push off the ground.")]
    [Range(5f, 25f)]
    [SerializeField] private float jumpForce = 8f;

    [Tooltip("How fast we fall.")]
    [Range(20f, 80f)]
    [SerializeField] private float gravity = 25f;

    [Tooltip("Extra gravity when falling.")]
    [Range(1f, 4f)]
    [SerializeField] private float fallGravityMultiplier = 2f;

    [Header("Ground Detection")]
    [SerializeField] private Vector3 groundCheckOffset = new Vector3(0, -0.9f, 0);
    [SerializeField] private float groundCheckRadius = 0.3f;
    [SerializeField] private LayerMask groundLayer;

    [Header("Movement")]
    [Tooltip("Walking speed")]
    [SerializeField] private float moveSpeed = 6f;

    [Tooltip("Air control multiplier")]
    [Range(0f, 1f)]
    [SerializeField] private float airControl = 0.3f;

    [Header("Mouse Look")]
    [Tooltip("The camera to rotate for vertical look")]
    [SerializeField] private Transform playerCamera;

    [Tooltip("Mouse sensitivity for gamepad")]
    [SerializeField] private float gamepadLookSpeed = 150f;

    [Tooltip("Mouse sensitivity multiplier")]
    [SerializeField] private float mouseSensitivity = 0.15f;

    [Tooltip("Maximum up/down look angle")]
    [Range(45f, 90f)]
    [SerializeField] private float maxLookAngle = 85f;

    [Header("Debug")]
    [SerializeField] private bool showGroundCheck = true;

    private CharacterController controller;
    private Vector3 velocity;
    private bool isGrounded;
    private float cameraPitch;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();

        // Lock and hide cursor for FPS
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
    }

    private void OnEnable()
    {
        if (InputReader.Instance != null)
        {
            InputReader.Instance.OnJumpPressed += HandleJump;
        }
    }

    private void OnDisable()
    {
        if (InputReader.Instance != null)
        {
            InputReader.Instance.OnJumpPressed -= HandleJump;
        }
    }

    private void Update()
    {
        CheckGrounded();
        HandleLook();
        HandleMovement();
        ApplyGravity();
        ApplyVelocity();
    }

    private void CheckGrounded()
    {
        Vector3 checkPosition = transform.position + groundCheckOffset;
        isGrounded = Physics.CheckSphere(checkPosition, groundCheckRadius, groundLayer);

        if (isGrounded && velocity.y < 0)
        {
            velocity.y = -2f;
        }
    }

    private void HandleLook()
    {
        if (InputReader.Instance == null) return;

        Vector2 lookInput = InputReader.Instance.LookInput;

        // Apply different sensitivity for mouse vs gamepad
        float lookSpeedX, lookSpeedY;
        if (InputReader.Instance.IsUsingGamepad)
        {
            lookSpeedX = gamepadLookSpeed * Time.deltaTime;
            lookSpeedY = gamepadLookSpeed * Time.deltaTime;
        }
        else
        {
            // Mouse input is already deltaTime-independent
            lookSpeedX = mouseSensitivity;
            lookSpeedY = mouseSensitivity;
        }

        // Horizontal rotation - rotate the whole player
        transform.Rotate(Vector3.up * lookInput.x * lookSpeedX);

        // Vertical rotation - rotate just the camera
        cameraPitch -= lookInput.y * lookSpeedY;
        cameraPitch = Mathf.Clamp(cameraPitch, -maxLookAngle, maxLookAngle);

        if (playerCamera != null)
        {
            playerCamera.localRotation = Quaternion.Euler(cameraPitch, 0f, 0f);
        }
    }

    private void HandleMovement()
    {
        Vector2 input = InputReader.Instance != null ? InputReader.Instance.MoveInput : Vector2.zero;

        // Movement relative to player facing direction
        Vector3 moveDirection = transform.forward * input.y + transform.right * input.x;

        float currentSpeed = moveSpeed;
        if (!isGrounded)
        {
            currentSpeed *= airControl;
        }

        velocity.x = moveDirection.x * currentSpeed;
        velocity.z = moveDirection.z * currentSpeed;
    }

    private void ApplyGravity()
    {
        if (!isGrounded)
        {
            float gravityThisFrame = gravity;
            if (velocity.y < 0)
            {
                gravityThisFrame *= fallGravityMultiplier;
            }
            velocity.y -= gravityThisFrame * Time.deltaTime;
        }
    }

    private void HandleJump()
    {
        if (isGrounded)
        {
            velocity.y = jumpForce;
        }
    }

    private void ApplyVelocity()
    {
        controller.Move(velocity * Time.deltaTime);
    }

    private void OnDrawGizmos()
    {
        if (showGroundCheck)
        {
            Vector3 checkPosition = transform.position + groundCheckOffset;
            Gizmos.color = isGrounded ? Color.green : Color.red;
            Gizmos.DrawWireSphere(checkPosition, groundCheckRadius);
        }
    }
}