342 lines
10 KiB
C#
Executable File
342 lines
10 KiB
C#
Executable File
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Media;
|
|
using Unity.Barracuda;
|
|
using UnityEngine;
|
|
using UnityEngine.InputSystem;
|
|
|
|
using static scr_Models;
|
|
|
|
public class scr_CharacterController : MonoBehaviour
|
|
{
|
|
|
|
private CharacterController characterController;
|
|
private DefaultInput defaultInput;
|
|
|
|
[HideInInspector]
|
|
public 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;
|
|
|
|
[HideInInspector]
|
|
public bool isSprinting;
|
|
|
|
private Vector3 newMovementSpeed;
|
|
private Vector3 newMovementSpeedVelocity;
|
|
|
|
[Header("Weapon")]
|
|
public scr_WeaponController currentWeapon;
|
|
|
|
public float weaponAnimationSpeed;
|
|
|
|
public float damage = 10f;
|
|
public float range = 100f;
|
|
|
|
public Camera fpsCam;
|
|
public ParticleSystem muzzleFlash;
|
|
public GameObject impactEffect;
|
|
|
|
public AudioClip aftergunSound;
|
|
public AudioSource gunSound;
|
|
|
|
public int count_of_bullets = 120;
|
|
public int count_of_bullets_gun = 30;
|
|
private int current_count_of_bullets_gun = 30;
|
|
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);
|
|
}
|
|
|
|
}
|
|
|
|
void PlayShootingSound()
|
|
{
|
|
gunSound.PlayOneShot(gunSound.clip);
|
|
gunSound.PlayOneShot(aftergunSound);
|
|
}
|
|
private void Update()
|
|
{
|
|
if (Input.GetKeyDown("r"))
|
|
{
|
|
Debug.Log("Reload");
|
|
int difference = 0;
|
|
if (count_of_bullets_gun == current_count_of_bullets_gun)
|
|
return;
|
|
if (current_count_of_bullets_gun < count_of_bullets_gun)
|
|
{
|
|
difference = count_of_bullets_gun - current_count_of_bullets_gun;
|
|
if (count_of_bullets > difference)
|
|
{
|
|
current_count_of_bullets_gun = count_of_bullets_gun;
|
|
count_of_bullets -= count_of_bullets_gun;
|
|
}
|
|
else
|
|
{
|
|
current_count_of_bullets_gun = count_of_bullets;
|
|
count_of_bullets = 0;
|
|
}
|
|
}
|
|
}
|
|
if (Input.GetButtonDown("Fire1") && current_count_of_bullets_gun > 0)
|
|
{
|
|
PlayShootingSound();
|
|
Shoot();
|
|
Debug.Log(current_count_of_bullets_gun);
|
|
current_count_of_bullets_gun -= 5;
|
|
}
|
|
CalculateView();
|
|
CalculateMovement();
|
|
CalculateJump();
|
|
CalculateCameraHeight();
|
|
}
|
|
|
|
void Shoot()
|
|
{
|
|
muzzleFlash.Play();
|
|
RaycastHit hit;
|
|
if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit, range))
|
|
{
|
|
Debug.Log(hit.transform.name);
|
|
|
|
Target target = hit.transform.GetComponent<Target>();
|
|
if (target != null)
|
|
{
|
|
target.TakeDamage(damage);
|
|
}
|
|
|
|
Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
weaponAnimationSpeed = characterController.velocity.magnitude / (playerSettings.WalkingForwardSpeed * playerSettings.SpeedEffector);
|
|
|
|
if (weaponAnimationSpeed > 1)
|
|
{
|
|
weaponAnimationSpeed = 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;
|
|
}
|
|
}
|
|
|
|
}
|