277 lines
9.6 KiB
C#
277 lines
9.6 KiB
C#
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;
|
|
|
|
[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("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();
|
|
|
|
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);
|
|
playerCamera.transform.localRotation = Quaternion.Euler(rotationX, 0, 0);
|
|
transform.rotation *= Quaternion.Euler(0, Input.GetAxis("Mouse X") * lookSpeedX, 0);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
}
|