PlayerMovement - Part 6.1

using UnityEngine;
using System.Collections;

public class PlayerMovement : MonoBehaviour
{
    public CharacterController controller;
    public float speed = 12f;
    public float gravity = -9.81f * 2;
    public float jumpHeight = 3f;
    public Transform groundCheck;
    public float groundDistance = 0.4f;
    public LayerMask groundMask;
    public Animator maleAnimator;
    public Animator femaleAnimator;
    public Transform maleCamera;
    public Transform femaleCamera;

    public BoxCollider groundTrigger;
    public BoxCollider normalTrigger;
    public BoxCollider highTrigger;

    public float crouchCameraX = 0.068f;
    public float crouchCameraY = 0.942f;
    public float crouchCameraZ = 0.407f;

    public float standCameraX = 0.04599719f;
    public float standCameraY = 1.734f;
    public float standCameraZ = 0.1539853f;

    private Vector3 originalMaleCameraPosition;
    private Vector3 crouchMaleCameraPosition;

    public bool isWalking;
    public bool isRunning;
    public bool isJumping;
    public bool isClimbing;
    public bool isCrouching;
    public bool isSwimming;
    public bool isTreadingWater;
    public bool CarryingLeftHandItem;
    public bool CarryingRightHandItem;
    public bool CarryingTwoHandedItem;
    public bool CarryingTwoItems;
    public bool isMoving;

    private const string ANIM_IS_WALKING = "isWalking";
    private const string ANIM_IS_RUNNING = "isRunning";
    private const string ANIM_IS_JUMPING = "isJumping";
    private const string ANIM_IS_CLIMBING = "isClimbing";
    private const string ANIM_IS_CROUCHING = "isCrouching";
    private const string ANIM_IS_SWIMMING = "isSwimming";
    private const string ANIM_IS_TREADING_WATER = "isTreadingWater";

    private const string ANIM_JUMP = "Jump";

    private const float ANIMATION_TRANSITION_SPEED = 0.1f;

    public Animator currentAnimator;
    public bool isMale = true;

    private Vector3 velocity;
    private bool isGrounded;

    private InteractionSystem interactionSystem;
    private InventorySystem inventorySystem;

    private Vector3 lastPosition;
    private bool isJumpingCoroutineRunning = false;

    public float interactionRange = 2f;
    public LayerMask interactableLayers;

    void Start()
    {
        controller = GetComponent<CharacterController>();
        interactionSystem = GetComponent<InteractionSystem>();
        inventorySystem = InventorySystem.Instance;
        UpdatePlayerReferences();

        originalMaleCameraPosition = new Vector3(standCameraX, standCameraY, standCameraZ);
        crouchMaleCameraPosition = new Vector3(crouchCameraX, crouchCameraY, crouchCameraZ);

        if (isMale)
        {
            maleCamera.localPosition = originalMaleCameraPosition;
        }

        lastPosition = transform.position;
    }

    void Update()
    {
        HandleMovement();
        HandleInteractions();
        UpdateAnimatorParameters();
        UpdateCameraPosition();
        UpdateHeldItemPositions();
    }

    void UpdatePlayerReferences()
    {
        currentAnimator = isMale ? maleAnimator : femaleAnimator;
    }

    void HandleMovement()
    {
        isGrounded = Physics.CheckSphere(groundCheck.position, groundDistance, groundMask);

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

        float x = Input.GetAxis("Horizontal");
        float z = Input.GetAxis("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;

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

        bool wasWalking = isWalking;
        isWalking = move.magnitude > 0.1f && !isRunning;
        isRunning = (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)) && move.magnitude > 0.1f;

        if (wasWalking != isWalking)
        {
            UpdateWalkingAnimation();
        }

        if (Input.GetButtonDown("Jump") && isGrounded && !isJumpingCoroutineRunning)
        {
            StartCoroutine(JumpCoroutine());
        }

        velocity.y += gravity * Time.deltaTime;

        controller.Move(velocity * Time.deltaTime);

        bool wasCrouching = isCrouching;
        isCrouching = Input.GetKey(KeyCode.LeftControl);

        if (isCrouching != wasCrouching)
        {
            UpdateCameraPosition();
            UpdateCrouchingAnimation();
        }
    }

    private void HandleInteractions()
    {
        if (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1))
        {
            RaycastHit hit;
            if (Physics.Raycast(Camera.main.transform.position, Camera.main.transform.forward, out hit, interactionRange, interactableLayers))
            {
                InteractableObject interactable = hit.collider.GetComponent<InteractableObject>();
                if (interactable != null)
                {
                    if (Input.GetMouseButtonDown(1) && interactable.item.isStorageItem)
                    {
                        // Right-click on storage item
                        interactable.Interact(this, true);
                    }
                    else if (Input.GetMouseButtonDown(0))
                    {
                        // Left-click on any interactable
                        interactable.Interact(this, false);
                    }
                }
            }
        }

        if (Input.GetKeyDown(KeyCode.P))
        {
            interactionSystem.TogglePrecisionDrop();
        }

        if (Input.GetKeyDown(KeyCode.G))
        {
            interactionSystem.DropItem(false);
        }
        if (Input.GetKeyDown(KeyCode.H))
        {
            interactionSystem.DropItem(true);
        }
        if (Input.GetKeyDown(KeyCode.F))
        {
            interactionSystem.DropBothItems();
        }
    }

    void UpdateAnimatorParameters()
    {
        currentAnimator.SetBool(ANIM_IS_WALKING, isWalking);
        currentAnimator.SetBool(ANIM_IS_RUNNING, isRunning);
        currentAnimator.SetBool(ANIM_IS_JUMPING, isJumping);
        currentAnimator.SetBool(ANIM_IS_CLIMBING, isClimbing);
        currentAnimator.SetBool(ANIM_IS_CROUCHING, isCrouching);
        currentAnimator.SetBool(ANIM_IS_SWIMMING, isSwimming);
        currentAnimator.SetBool(ANIM_IS_TREADING_WATER, isTreadingWater);
        currentAnimator.SetBool("isMoving", isMoving);
    }

    void UpdateWalkingAnimation()
    {
        if (isWalking)
        {
            currentAnimator.CrossFadeInFixedTime("Walking", ANIMATION_TRANSITION_SPEED);
        }
        else
        {
            currentAnimator.CrossFadeInFixedTime("Idle", ANIMATION_TRANSITION_SPEED);
        }
    }

    void UpdateCrouchingAnimation()
    {
        currentAnimator.CrossFadeInFixedTime(isCrouching ? "Crouching Idle" : "Idle", ANIMATION_TRANSITION_SPEED);
    }

    void UpdateCameraPosition()
    {
        if (isMale)
        {
            maleCamera.localPosition = isCrouching ? crouchMaleCameraPosition : originalMaleCameraPosition;
        }
    }

    public void PlayGrabbingAnimation(bool isLeftHand, string height)
    {
        string animationName = GetPickUpAnimationName(isLeftHand, height);
        currentAnimator.Play(animationName, 0, 0f);
    }

    private string GetPickUpAnimationName(bool isLeftHand, string height)
    {
        string hand = isLeftHand ? "Left" : "Right";
        return $"Pick up Single Handed Object from {height} ({hand})";
    }

    public void UpdateCarryingAnimations()
    {
        bool leftHandItem = inventorySystem.leftHandItem != null;
        bool rightHandItem = inventorySystem.rightHandItem != null;
        bool twoHandedItem = leftHandItem && inventorySystem.leftHandItem.isTwoHanded;

        string carryAnimation = GetCarryingAnimationName(leftHandItem, rightHandItem, twoHandedItem);

        if (!string.IsNullOrEmpty(carryAnimation))
        {
            currentAnimator.CrossFadeInFixedTime(carryAnimation, ANIMATION_TRANSITION_SPEED);
        }

        currentAnimator.SetBool("CarryingLeftHandItem", leftHandItem && !twoHandedItem);
        currentAnimator.SetBool("CarryingRightHandItem", rightHandItem && !twoHandedItem);
        currentAnimator.SetBool("CarryingTwoHandedItem", twoHandedItem);
        currentAnimator.SetBool("CarryingTwoItems", leftHandItem && rightHandItem && !twoHandedItem);
    }

    private string GetCarryingAnimationName(bool leftHandItem, bool rightHandItem, bool twoHandedItem)
    {
        if (twoHandedItem) return "carrying a two handed item";
        if (leftHandItem && rightHandItem) return "carrying two single handed items";
        if (leftHandItem) return "Carrying one handed item (Left)";
        if (rightHandItem) return "Carrying one handed item (Right)";
        return null;
    }

    void UpdateHeldItemPositions()
    {
        if (inventorySystem.leftHandItem != null)
        {
            UpdateItemPosition(inventorySystem.leftHandItem.gameObject, true);
        }
        if (inventorySystem.rightHandItem != null)
        {
            UpdateItemPosition(inventorySystem.rightHandItem.gameObject, false);
        }
    }

    public void UpdateItemPosition(GameObject itemObject, bool isLeftHand)
    {
        Transform objectHolder = isLeftHand ? interactionSystem.leftObjectHolder : interactionSystem.rightObjectHolder;
        Item item = itemObject.GetComponent<Item>();

        bool isHoldingTwoItems = inventorySystem.leftHandItem != null && inventorySystem.rightHandItem != null;

        Vector3 positionOffset = isLeftHand ?
            (isHoldingTwoItems ? item.leftTwoPositionOffset : item.leftPositionOffset) :
            (isHoldingTwoItems ? item.rightTwoPositionOffset : item.rightPositionOffset);

        Vector3 rotationOffset = isLeftHand ?
            (isHoldingTwoItems ? item.leftTwoRotationOffset : item.leftRotationOffset) :
            (isHoldingTwoItems ? item.rightTwoRotationOffset : item.rightRotationOffset);

        itemObject.transform.position = objectHolder.position + objectHolder.TransformDirection(positionOffset);
        itemObject.transform.rotation = objectHolder.rotation * Quaternion.Euler(rotationOffset);
    }

    public string GetPickUpHeight(Vector3 itemPosition)
    {
        if (highTrigger.bounds.Contains(itemPosition))
            return "High Surface";
        else if (normalTrigger.bounds.Contains(itemPosition))
            return "Normal Surface";
        else if (groundTrigger.bounds.Contains(itemPosition))
            return "Ground";
        else
            return "Normal Surface";
    }

    private IEnumerator JumpCoroutine()
    {
        isJumpingCoroutineRunning = true;
        currentAnimator.Play(ANIM_JUMP, 0, 0f);
        velocity.y = Mathf.Sqrt(jumpHeight * -2f * gravity);
        isJumping = true;
        yield return new WaitForSeconds(currentAnimator.GetCurrentAnimatorStateInfo(0).length);
        isJumpingCoroutineRunning = false;
    }

    public void TryPickUpItem(InteractableObject interactable)
    {
        Item item = interactable.item;

        if (item.isBackpack)
        {
            // Store reference and show backpack-specific prompt
            interactionSystem.currentBackpackItem = item;
            UIManager.Instance.ShowBackpackPrompt(item);
        }
        else
        {
            // Existing pickup logic
            bool isLeftHand = inventorySystem.rightHandItem != null && inventorySystem.leftHandItem == null;

            if (item.isTwoHanded)
            {
                if (inventorySystem.leftHandItem == null && inventorySystem.rightHandItem == null)
                {
                    EquipItem(item, true, true);
                }
                else
                {
                    Debug.Log("Cannot pick up two-handed item. Hands are not empty.");
                }
            }
            else if (inventorySystem.rightHandItem == null || isLeftHand)
            {
                EquipItem(item, isLeftHand, false);
            }
            else
            {
                Debug.Log("Cannot pick up item. Both hands are full.");
            }
        }
    }

    private void EquipItem(Item item, bool isLeftHand, bool isTwoHanded)
    {
        inventorySystem.EquipItem(item, isLeftHand, isTwoHanded);
        interactionSystem.UpdateItemPosition(item.gameObject, isLeftHand);
        interactionSystem.ChangeItemLayer(item.gameObject, interactionSystem.pickupLayer);
        UpdateCarryingAnimations();
    }

    public void SetClimbingState(bool climbing)
    {
        isClimbing = climbing;
    }

    public void SetSwimmingState(bool swimming)
    {
        isSwimming = swimming;
    }

    public void SetTreadingWaterState(bool treadingWater)
    {
        isTreadingWater = treadingWater;
    }
}