code

using UnityEngine;
using System.Collections;
using System.Diagnostics;

[RequireComponent(typeof(CharacterController))]
public class FPSController : MonoBehaviour
{
    [Header("Look Settings")]
    public Transform playerCamera;
    public float mouseSensitivity = 100f;
    public float maxLookAngle = 90f;
    public Transform cameraPivot;

    [Header("Movement Settings")]
    public float walkSpeed = 5f;
    public float runSpeed = 8f;
    public float crouchSpeed = 3f;
    public float jumpHeight = 1.5f;
    public float gravity = -9.81f;

    [Header("Keybinds")]
    public KeyCode runKey = KeyCode.LeftShift;
    public KeyCode crouchKey = KeyCode.LeftControl;

    [Header("Kick Settings")]
    public float kickRange = 2f;
    public float kickForce = 500f;
    public float kickCooldown = 1f;
    public LayerMask kickableLayers;

    private bool isKicking = false;
    private float kickTimer = 0f;

    [Header("Slide Settings")]
    public float slideSpeed = 10f;
    public float slideDuration = 1f;
    public float slideCooldown = 1.5f;
    public float slideHeight = 1f;

    [Header("Crouch/Slide Shared Settings")]
    public float crouchHeight = 1.2f;
    public float crouchCameraHeight = 0.8f;
    public float cameraSmoothSpeed = 8f;

    [Header("Model Settings")]
    public Transform playerModel;
    public float modelYWhenStanding = 0f;
    public float modelYWhenCrouching = -0.5f;
    public float modelYWhenSliding = -0.7f;

    [Header("Ground Check Settings")]
    public float groundCheckDistance = 0.4f;
    public float groundCheckRadius = 0.3f;
    public LayerMask groundMask;

    private CharacterController controller;
    private Animator animator;

    private float cameraPitch;
    private float originalHeight;
    private Vector3 originalCenter;
    private float originalCameraY;
    private float targetCameraY;
    private bool isPointing = false;

    private Vector3 velocity;
    private bool isSliding = false;
    private bool isCrouching = false;
    private float slideCooldownTimer = 0f;
    private bool isGrounded = false;

    void Start()
    {
        controller = GetComponent<CharacterController>();
        animator = GetComponentInChildren<Animator>();
        animator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;

        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;

        cameraPitch = 0f;
        playerCamera.localRotation = Quaternion.Euler(cameraPitch, 0f, 0f);

        originalHeight = controller.height;
        originalCenter = controller.center;
        originalCameraY = playerCamera.localPosition.y;
        targetCameraY = originalCameraY;

        if (playerCamera == null)
            UnityEngine.Debug.LogError("PlayerCamera not assigned!");
        if (playerModel == null)
            UnityEngine.Debug.LogError("Player model not assigned!");
    }

    void Update()
    {
        GroundCheck();
        Look();
        Move();

        kickTimer -= Time.deltaTime;

        if (Input.GetKeyDown(KeyCode.Alpha1))
        {
            isPointing = true;
            animator.SetBool("IsPointing", true);
        }

        if (isPointing && Input.GetMouseButtonDown(0))
        {
            isPointing = false;
            animator.SetBool("IsPointing", false);
        }

        if (Input.GetKeyDown(KeyCode.F) && kickTimer <= 0f && !isKicking && isGrounded)
        {
            StartCoroutine(PerformKick());
        }

        slideCooldownTimer -= Time.deltaTime;

        Vector3 camPos = playerCamera.localPosition;
        camPos.y = Mathf.Lerp(camPos.y, targetCameraY, Time.deltaTime * cameraSmoothSpeed);
        playerCamera.localPosition = camPos;

        UpdateModelPosition();
    }

    void Look()
    {
        float mouseX = Input.GetAxis("Mouse X") * mouseSensitivity * Time.deltaTime;
        float mouseY = Input.GetAxis("Mouse Y") * mouseSensitivity * Time.deltaTime;

        cameraPitch -= mouseY;
        cameraPitch = Mathf.Clamp(cameraPitch, -maxLookAngle, maxLookAngle);

        cameraPivot.localRotation = Quaternion.Euler(cameraPitch, 0f, 0f);
        transform.Rotate(Vector3.up * mouseX);
    }

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

        float moveX = Input.GetAxis("Horizontal");
        float moveZ = Input.GetAxis("Vertical");

        Vector3 move = transform.right * moveX + transform.forward * moveZ;
        float speed = walkSpeed;

        bool isRunning = Input.GetKey(runKey) && !isSliding && !isCrouching;
        if (isRunning) speed = runSpeed;
        else if (isCrouching) speed = crouchSpeed;

        if (Input.GetKeyDown(crouchKey) && Input.GetKey(runKey) && isGrounded && slideCooldownTimer <= 0 && !isSliding)
            StartCoroutine(Slide());

        if (!isSliding && Input.GetKey(crouchKey) && !Input.GetKey(runKey))
            StartCrouch();
        else if (!isSliding && !Input.GetKey(crouchKey) && isCrouching && CanStandUp())
            StopCrouch();

        controller.Move(move * speed * Time.deltaTime);

        if (Input.GetButtonDown("Jump") && isGrounded && !isSliding && !isCrouching)
        {
            velocity.y = Mathf.Sqrt(jumpHeight * -2f * gravity);
            animator.SetTrigger("Jump");
        }

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);

        animator.SetFloat("Speed", move.magnitude * speed);
        animator.SetBool("IsSliding", isSliding);
        animator.SetBool("IsCrouch", isCrouching);
        animator.SetBool("IsGrounded", isGrounded);
        animator.SetBool("IsFalling", !isGrounded && velocity.y < 0);
    }

    void GroundCheck()
    {
        Vector3 origin = transform.position + Vector3.up * (controller.radius + 0.1f);
        isGrounded = Physics.SphereCast(origin, groundCheckRadius, Vector3.down, out RaycastHit hit, groundCheckDistance, groundMask);
    }

    bool IsHeadBlocked()
    {
        float radius = controller.radius * 0.95f;
        Vector3 bottom = transform.position + Vector3.up * crouchHeight;
        Vector3 top = transform.position + Vector3.up * (originalHeight - 0.05f);
        return Physics.CheckCapsule(bottom, top, radius, groundMask);
    }

    bool CanStandUp()
    {
        return !IsHeadBlocked();
    }

    IEnumerator Slide()
    {
        isSliding = true;
        slideCooldownTimer = slideCooldown;

        controller.height = slideHeight;
        controller.center = new Vector3(0, originalCenter.y - (originalHeight - slideHeight) / 2f, 0);
        targetCameraY = crouchCameraHeight;

        float elapsed = 0f;
        while (elapsed < slideDuration)
        {
            Vector3 slideDir = transform.forward;
            controller.Move(slideDir * slideSpeed * Time.deltaTime);
            elapsed += Time.deltaTime;
            yield return null;
        }

        controller.height = crouchHeight;
        controller.center = new Vector3(0, originalCenter.y - (originalHeight - crouchHeight) / 2f, 0);
        targetCameraY = crouchCameraHeight;

        isSliding = false;
        isCrouching = true;
    }

    IEnumerator PerformKick()
    {
        isKicking = true;
        kickTimer = kickCooldown;

        animator.SetTrigger("Kick");

        yield return new WaitForSeconds(0.2f);

        if (Physics.Raycast(playerCamera.position, playerCamera.forward, out RaycastHit hit, kickRange, kickableLayers))
        {
            Rigidbody rb = hit.collider.attachedRigidbody;
            if (rb != null)
            {
                Vector3 forceDir = hit.point - playerCamera.position;
                forceDir.Normalize();
                rb.AddForce(forceDir * kickForce, ForceMode.Impulse);
            }
        }

        yield return new WaitForSeconds(0.3f);

        isKicking = false;
    }

    void StartCrouch()
    {
        if (isCrouching) return;

        isCrouching = true;
        controller.height = crouchHeight;
        controller.center = new Vector3(0, originalCenter.y - (originalHeight - crouchHeight) / 2f, 0);
        targetCameraY = crouchCameraHeight;
    }

    void StopCrouch()
    {
        isCrouching = false;
        controller.height = originalHeight;
        controller.center = originalCenter;
        targetCameraY = originalCameraY;
    }

    void UpdateModelPosition()
    {
        float modelY = modelYWhenStanding;

        if (isSliding)
            modelY = modelYWhenSliding;
        else if (isCrouching)
            modelY = modelYWhenCrouching;

        float targetY = isSliding ? modelY : Mathf.Lerp(playerModel.localPosition.y, modelY, Time.deltaTime * cameraSmoothSpeed);

        Vector3 modelLocalPos = playerModel.localPosition;
        modelLocalPos.y = targetY;
        playerModel.localPosition = modelLocalPos;
    }

    void OnDrawGizmosSelected()
    {
        if (controller == null) return;

        Gizmos.color = Color.yellow;
        float radius = controller.radius * 0.95f;

        Vector3 bottom = transform.position + Vector3.up * crouchHeight;
        Vector3 top = transform.position + Vector3.up * (originalHeight - 0.05f);

        Gizmos.color = Color.red;
        Gizmos.DrawRay(playerCamera.position, playerCamera.forward * kickRange);
        Gizmos.DrawWireSphere(bottom, radius);
        Gizmos.DrawWireSphere(top, radius);
        Gizmos.DrawLine(bottom + Vector3.forward * radius, top + Vector3.forward * radius);
        Gizmos.DrawLine(bottom - Vector3.forward * radius, top - Vector3.forward * radius);
        Gizmos.DrawLine(bottom + Vector3.right * radius, top + Vector3.right * radius);
        Gizmos.DrawLine(bottom - Vector3.right * radius, top - Vector3.right * radius);
    }
}