projectEli/Assets/Scripts/FirstPersonController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using SimpleInventorySystem;

public class FirstPersonController : MonoBehaviour
{
    public InventorySystem inventorySystem; // Reference to the InventorySystem script

    // Start is called before the first frame update
    public bool CanMove { get; private set; } = true;
    private bool IsSprinting => canSprint && Input.GetKey(sprintKey);
    private bool ShouldJump => Input.GetKeyDown(jumpKey) && characterController.isGrounded;
    private bool ShouldCrouch => Input.GetKeyDown(crouchKey) && !duringCrouchAnimation && characterController.isGrounded;

    [Header("Functional Options")]
    [SerializeField] private bool canSprint = true;
    [SerializeField] private bool canJump = true;
    [SerializeField] private bool canCrouch = true;
    [SerializeField] private bool canUseHeadbob = true;
    [SerializeField] private bool canLean = true;


    [Header("Controls")]
    [SerializeField] private KeyCode sprintKey = KeyCode.LeftShift;
    [SerializeField] private KeyCode jumpKey = KeyCode.Space;
    [SerializeField] private KeyCode crouchKey = KeyCode.C;

    [Header("Movement Parameters")]
    [SerializeField] private float minWalkSpeed = 1.0f;
    [SerializeField] private float maxWalkSpeed = 5.0f;
    [SerializeField] private float walkSpeedInterval = 0.5f;
    private float currentWalkSpeed;


    [SerializeField] private float walkSpeed = 3.0f;
    [SerializeField] private float sprintSpeed = 6.0f;
    [SerializeField] private float crouchSpeed = 1.5f;


    [Header("Look Parameters")]
    [SerializeField, Range(1, 10)] private float lookSpeedX = 2.0f;
    [SerializeField, Range(1, 10)] private float lookSpeedY = 2.0f;
    [SerializeField, Range(1, 180)] private float upperLookLimit = 80.0f;
    [SerializeField, Range(1, 180)] private float lowerLookLimit = 80.0f;


    [Header("Leaning Parameters")]
    [SerializeField] private bool toggleLeaning = false; // Toggle mode
    [SerializeField] private KeyCode leanLeftKey = KeyCode.Q;
    [SerializeField] private KeyCode leanRightKey = KeyCode.E;
    [SerializeField, Range(1, 45)] private float maxLeaningAngle = 15.0f;
    private float currentLeaningAngle;
    private bool isLeaningLeft;
    private bool isLeaningRight;


    [Header("Jumping Parameters")]
    [SerializeField] private float jumpForce = 8.0f;
    [SerializeField] private float gravity = 30.0f;

    [Header("Crouch Parameters")]
    [SerializeField] private float crouchHeightInterval = 0.1f;
    [SerializeField] private float crouchHeight = 0.5f;
    [SerializeField] private float standingHeight = 2.0f;
    [SerializeField] private float timeToCrouch = 0.25f;
    [SerializeField] private Vector3 crouchingCenter = new Vector3(0, 0.5f, 0);
    [SerializeField] private Vector3 standingCenter = new Vector3(0, 0, 0);
    private bool isCrouching;
    private bool duringCrouchAnimation;

    private float targetCrouchHeight; // The target crouch height to apply when "C" key is released
    private float tempCrouchHeight; // The temporary crouch height while "C" key is held
    private float currentCrouchHeight;
    private float minCrouchHeight = 0.5f; // Minimum crouch height
    private bool isCrouchKeyHeld;
    private bool crouchHeightAdjustmentEnabled; // Flag to enable crouch height adjustment

    [Header("Headbob Parameters")]
    [SerializeField] private float walkBobSpeed = 14f;
    [SerializeField] private float walkBobAmount = 0.05f;
    [SerializeField] private float sprintBobSpeed = 18f;
    [SerializeField] private float sprintBobAmount = 0.1f;
    [SerializeField] private float crouchBobSpeed = 8f;
    [SerializeField] private float crouchBobAmount = 0.025f;
    private float defaultYPos = 0;
    private float timer;

    private Camera playerCamera;
    private CharacterController characterController;

    private Vector3 moveDirection;
    private Vector2 currentInput;

    private float rotationX = 0;

    void Awake()
    {
        playerCamera = GetComponentInChildren<Camera>();
        characterController = GetComponent<CharacterController>();
        defaultYPos = playerCamera.transform.localPosition.y;
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
        currentWalkSpeed = walkSpeed;
        currentCrouchHeight = crouchHeight;
    }

    // Update is called once per frame
    void Update()
    {
        // Check if the inventory UI is open
        bool isInventoryUIOpen = inventorySystem.IsUsingInventoryMenuUI();

        if (isInventoryUIOpen)
        {
            // The inventory UI is open, disable movement
            CanMove = false;
        }
        else
        {
            // The inventory UI is closed, enable movement
            CanMove = true;
            HandleMovementInput();
            HandleMouseLook();
            HandleSpeedChange();
            HandleCrouchAdjustment();

            if (canJump)
                HandleJump();

            if (canCrouch)
                HandleCrouch();

            if (canUseHeadbob)
                HandleHeadbob();

            if (canLean)
                HandleLeaning(); // Added the HandleLeaning method call here.

            ApplyFinalMovements();
        }
    }



    private void HandleMovementInput()
    {
        currentInput = new Vector2((isCrouching ? crouchSpeed : IsSprinting ? sprintSpeed : walkSpeed) * Input.GetAxis("Vertical"), (isCrouching ? crouchSpeed : IsSprinting ? sprintSpeed : walkSpeed) * Input.GetAxis("Horizontal"));

        float moveDirectionY = moveDirection.y;
        moveDirection = (transform.TransformDirection(Vector3.forward) * currentInput.x) + (transform.TransformDirection(Vector3.right) * currentInput.y);
        moveDirection.y = moveDirectionY;
    }

    private void HandleJump()
    {
        if (ShouldJump)
            moveDirection.y = jumpForce;
    }

    private void HandleCrouch()
    {
        if (Input.GetKeyDown(crouchKey) && !duringCrouchAnimation && characterController.isGrounded)
        {
            isCrouchKeyHeld = true;
            tempCrouchHeight = currentCrouchHeight;
            crouchHeightAdjustmentEnabled = true; // Enable crouch height adjustment
        }

        if (Input.GetKeyUp(crouchKey) && isCrouchKeyHeld)
        {
            // "C" key is released, apply the new crouch height
            targetCrouchHeight = tempCrouchHeight;
            isCrouchKeyHeld = false;
            StartCoroutine(CrouchStand());
        }
    }

    private void HandleCrouchAdjustment()
    {
        // Adjust the crouch height based on the scroll wheel input
        float scroll = Input.GetAxis("Mouse ScrollWheel");

        if (scroll > 0)
        {
            // Increase temporary crouch height if within the maximum limit
            if (tempCrouchHeight < standingHeight)
            {
                tempCrouchHeight += crouchHeightInterval;
            }
        }
        else if (scroll < 0)
        {
            // Decrease temporary crouch height if within the minimum limit
            if (tempCrouchHeight > minCrouchHeight)
            {
                tempCrouchHeight -= crouchHeightInterval;
            }
        }

        // Update the actual crouch height with the temporary crouch height
        crouchHeight = tempCrouchHeight;
    }

    private IEnumerator CrouchStand()
    {
        if (isCrouching && Physics.Raycast(playerCamera.transform.position, Vector3.up, 1f))
            yield break;
        duringCrouchAnimation = true;

        float timeElapsed = 0;
        float targetHeight = isCrouching ? standingHeight : currentCrouchHeight; // Use currentCrouchHeight here
        float currentHeight = characterController.height;
        Vector3 targetCenter = isCrouching ? standingCenter : crouchingCenter;
        Vector3 currentCenter = characterController.center;

        while (timeElapsed < timeToCrouch)
        {
            characterController.height = Mathf.Lerp(currentHeight, targetHeight, timeElapsed / timeToCrouch);
            characterController.center = Vector3.Lerp(currentCenter, targetCenter, timeElapsed / timeToCrouch);
            timeElapsed += Time.deltaTime;
            yield return null;
        }

        characterController.height = targetHeight;
        characterController.center = targetCenter;

        isCrouching = !isCrouching;
        duringCrouchAnimation = false;

        // Update crouchHeight with currentCrouchHeight
        crouchHeight = currentCrouchHeight;
    }

    private void HandleHeadbob()
    {
        if (!characterController.isGrounded) return;

        if (Mathf.Abs(moveDirection.x) > 0.1f || Mathf.Abs(moveDirection.z) > 0.1f)
        {
            timer += Time.deltaTime * (isCrouching ? crouchBobSpeed : IsSprinting ? sprintBobSpeed : walkBobSpeed);
            playerCamera.transform.localPosition = new Vector3(
                playerCamera.transform.localPosition.x,
                defaultYPos + Mathf.Sin(timer) * (isCrouching ? crouchBobAmount : IsSprinting ? sprintBobAmount : walkBobAmount),
                playerCamera.transform.localPosition.z);
        }

    }

    private void HandleMouseLook()
    {
        rotationX -= Input.GetAxis("Mouse Y") * lookSpeedY;
        rotationX = Mathf.Clamp(rotationX, -upperLookLimit, lowerLookLimit);

        // Apply the current leaning angle to the camera's rotation
        playerCamera.transform.localRotation = Quaternion.Euler(rotationX + currentLeaningAngle, 0, 0);
        transform.rotation *= Quaternion.Euler(0, Input.GetAxis("Mouse X") * lookSpeedX, 0);
    }

    private void HandleLeaning()
    {
        if (toggleLeaning)
        {
            if (Input.GetKeyDown(leanLeftKey))
            {
                isLeaningLeft = !isLeaningLeft;
                isLeaningRight = false;
            }
            if (Input.GetKeyDown(leanRightKey))
            {
                isLeaningRight = !isLeaningRight;
                isLeaningLeft = false;
            }
        }
        else
        {
            if (Input.GetKey(leanLeftKey) && !isLeaningRight)
            {
                isLeaningLeft = true;
                isLeaningRight = false;
            }
            if (Input.GetKey(leanRightKey) && !isLeaningLeft)
            {
                isLeaningRight = true;
                isLeaningLeft = false;
            }
        }

        // Apply the current leaning angle using the maximum leaning angle
        currentLeaningAngle = Mathf.Clamp(currentLeaningAngle, -maxLeaningAngle, maxLeaningAngle);
    }

    private void ApplyFinalMovements()
    {
        if (!characterController.isGrounded)
            moveDirection.y -= gravity * Time.deltaTime;

        characterController.Move(moveDirection * Time.deltaTime);
    }

    private void HandleSpeedChange()
    {
        float scroll = Input.GetAxis("Mouse ScrollWheel");

        if (scroll > 0)
        {
            // Increase walk speed if within the maximum limit
            if (currentWalkSpeed < maxWalkSpeed)
            {
                currentWalkSpeed += walkSpeedInterval;
            }
        }
        else if (scroll < 0)
        {
            // Decrease walk speed if within the minimum limit
            if (currentWalkSpeed > minWalkSpeed)
            {
                currentWalkSpeed -= walkSpeedInterval;
            }
        }

        // Update the walk speed
        walkSpeed = currentWalkSpeed;
    }

}