Initial. Added files

Assets/Scripts/Character/scr_CharacterController.cs

@@ -0,0 +1,259 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Barracuda;
+using UnityEngine;
+
+using static scr_Models; 
+
+public class scr_CharacterController : MonoBehaviour
+{
+
+    private CharacterController characterController;
+    private DefaultInput defaultInput;
+    private Vector2 input_Movement;
+    [HideInInspector]
+    public Vector2 input_View;
+   
+    private Vector3 newCameraRotation;
+    private Vector3 newCharacterRotation;
+
+    [Header("References")]
+    public Transform cameraHolder;
+    public Transform feetTransform;
+
+    [Header("Settings")] 
+    public PlayerSettingsModel playerSettings;
+
+    public float ViewClampYMin = -70;
+    public float ViewClampYMax = 80;
+    public LayerMask playerMask;
+    
+    [Header("Gravity")] 
+    public float gravityAmount;
+    public float gravityMin;
+    private float playerGravity;
+
+    public Vector3 jumpingForce;
+    private Vector3 jumpingForceVelocity;
+
+    [Header("Stance")] 
+    public PlayerStance playerStance;
+    public float playerStanceSmoothing;
+    public CharacterStance playerStandStance;
+    public CharacterStance playerCrouchStance;
+    public CharacterStance playerProneStance;
+    private float stanceCheckErrorMargin = 0.05f;
+    
+    private float cameraHeight;
+    private float cameraHeightVelocity;
+
+    private bool isSprinting;
+
+    private Vector3 newMovementSpeed;
+    private Vector3 newMovementSpeedVelocity;
+
+    [Header("Weapon")] public scr_WeaponController currentWeapon;
+    private void Awake()
+    {
+        defaultInput = new DefaultInput();
+
+        defaultInput.Character.Movement.performed += e => input_Movement = e.ReadValue<Vector2>();
+        defaultInput.Character.View.performed += e => input_View = e.ReadValue<Vector2>();
+        defaultInput.Character.Jump.performed += e => Jump();
+        
+        defaultInput.Character.Crouch.performed += e => Crouch();
+        defaultInput.Character.Prone.performed += e => Prone();
+        
+        defaultInput.Character.Sprint.performed += e => ToggleSprint();
+        defaultInput.Character.SprintReleased.performed += e => StopSprint();
+      
+        defaultInput.Enable();
+
+        newCameraRotation = cameraHolder.localRotation.eulerAngles;
+        newCharacterRotation = transform.localRotation.eulerAngles;
+        characterController = GetComponent<CharacterController>();
+
+        cameraHeight = cameraHolder.localPosition.y;
+
+        if (currentWeapon)
+        {
+            currentWeapon.Initialise(this);
+        }
+        
+    }
+
+    private void Update()
+    {
+        CalculateView();
+        CalculateMovement();
+        CalculateJump();
+        CalculateCameraHeight();
+    }
+
+    private void CalculateView()
+    {
+        newCharacterRotation.y += playerSettings.ViewXSensetivity * (playerSettings.ViewXInverted ? -input_View.x : input_View.x) * Time.deltaTime;
+        transform.localRotation = Quaternion.Euler(newCharacterRotation);
+        
+        newCameraRotation.x += playerSettings.ViewYSensetivity * (playerSettings.ViewYInverted ? input_View.y : -input_View.y) * Time.deltaTime;
+        newCameraRotation.x = Mathf.Clamp(newCameraRotation.x, ViewClampYMin, ViewClampYMax);
+        
+        cameraHolder.localRotation = Quaternion.Euler(newCameraRotation);
+    }
+
+    private void CalculateMovement()
+    {
+        if (input_Movement.y <= 0.2f)
+        {
+            isSprinting = false;
+        }
+        
+        var verticalSpeed = playerSettings.WalkingForwardSpeed;
+        var horizontalSpeed = playerSettings.WalkingStrafeSpeed;
+
+        if (isSprinting)
+        {
+            verticalSpeed = playerSettings.RunningForwardSpeed;
+            horizontalSpeed = playerSettings.RunningStrafeSpeed;
+        }
+        
+        // Effectors
+        if (!characterController.isGrounded)
+        {
+            playerSettings.SpeedEffector = playerSettings.FallingSpeedEffector;
+        }
+        else if(playerStance == PlayerStance.Crouch)
+        {
+            playerSettings.SpeedEffector = playerSettings.CrouchSpeedEffector;
+        } 
+        else if(playerStance == PlayerStance.Prone)
+        {
+            playerSettings.SpeedEffector = playerSettings.ProneSpeedEffector;
+        }
+        else
+        {
+            playerSettings.SpeedEffector = 1;
+        }
+        
+        verticalSpeed *= playerSettings.SpeedEffector;
+        horizontalSpeed *= playerSettings.SpeedEffector;
+        
+        newMovementSpeed = Vector3.SmoothDamp(newMovementSpeed,
+       new Vector3(horizontalSpeed * input_Movement.x * Time.deltaTime,
+          0, verticalSpeed * input_Movement.y * Time.deltaTime),
+            ref newMovementSpeedVelocity, characterController.isGrounded ? playerSettings.MovementSmoothing : playerSettings.FallingSmoothing);
+        
+        var MovementSpeed = transform.TransformDirection(newMovementSpeed);
+
+        if (playerGravity > gravityMin)
+        {
+            playerGravity -= gravityAmount * Time.deltaTime;
+        }
+
+        if (playerGravity < -0.1f && characterController.isGrounded)
+        {
+            playerGravity = -0.1f;
+        }
+
+        MovementSpeed.y += playerGravity;
+        MovementSpeed += jumpingForce * Time.deltaTime;
+        
+        characterController.Move(MovementSpeed);
+    }
+
+    private void CalculateJump()
+    {
+        jumpingForce = Vector3.SmoothDamp(jumpingForce, Vector3.zero, ref jumpingForceVelocity, playerSettings.JumpingFalloff);
+    }
+
+    private void CalculateCameraHeight()
+    {
+        var stanceHeight = playerStandStance.CameraHeight;
+
+        if (playerStance == PlayerStance.Crouch)
+        {
+            stanceHeight = playerCrouchStance.CameraHeight;
+        }
+        else if (playerStance == PlayerStance.Prone)
+        {
+            stanceHeight = playerProneStance.CameraHeight;
+        }
+        
+        cameraHeight = Mathf.SmoothDamp(cameraHolder.localPosition.y, stanceHeight, ref cameraHeightVelocity, playerStanceSmoothing);
+
+        cameraHolder.localPosition = new Vector3(cameraHolder.localPosition.x, cameraHeight, cameraHolder.localPosition.z);
+    }
+    private void Jump()
+    {
+        if (!characterController.isGrounded || playerStance == PlayerStance.Prone)
+        {
+            return;
+        }
+        
+        if (playerStance == PlayerStance.Crouch)
+        {
+            if (StanceCheck(playerStandStance.StanceCollider.height))
+            {
+                return;
+            }
+            playerStance = PlayerStance.Stand;
+            return;
+        }
+        
+        // Jump
+        jumpingForce = Vector3.up * playerSettings.JumpingHeight;
+        playerGravity = 0;
+    }
+
+    private void Crouch()
+    {
+        if (playerStance == PlayerStance.Crouch)
+        {
+            if (StanceCheck(playerStandStance.StanceCollider.height))
+            {
+                return;
+            }
+            playerStance = PlayerStance.Stand;
+            return;
+        }
+        if (StanceCheck(playerCrouchStance.StanceCollider.height))
+        {
+            return;
+        }
+        playerStance = PlayerStance.Crouch;
+    }
+
+    private void Prone()
+    {
+        playerStance = PlayerStance.Prone;
+    }
+
+    private bool StanceCheck(float stanceCheckheight)
+    {
+        var start = new Vector3(feetTransform.position.x, feetTransform.position.y + characterController.radius + stanceCheckErrorMargin, feetTransform.position.z);
+        var end = new Vector3(feetTransform.position.x, feetTransform.position.y - characterController.radius - stanceCheckErrorMargin + stanceCheckheight, feetTransform.position.z);
+        
+        
+        return Physics.CheckCapsule(start, end, characterController.radius, playerMask);
+    }
+
+    private void ToggleSprint()
+    {
+        if (input_Movement.y <= 0.2f)
+        {
+            isSprinting = false;
+            return;
+        }
+        isSprinting = !isSprinting;
+    }
+    
+    private void StopSprint()
+    {
+        if (playerSettings.SprintingHold)
+        {
+            isSprinting = false;
+        }
+    }
+    
+}