修改FPS控制

Assets/Scripts/FirstPersonController/FirstPersonController.cs

@@ -0,0 +1,324 @@
+using UnityEngine;
+
+namespace NBF
+{
+    [RequireComponent(typeof(CharacterController))]
+    [RequireComponent(typeof(AudioSource))]
+    public class FirstPersonController : MonoBehaviour
+    {
+        [SerializeField] private bool m_IsWalking;
+
+        [SerializeField] public float m_WalkSpeed;
+
+        [SerializeField] public float m_RunSpeed;
+
+        [SerializeField] [Range(0f, 1f)] private float m_RunstepLenghten;
+
+        [SerializeField] private float m_JumpSpeed;
+
+        [SerializeField] private float m_StickToGroundForce;
+
+        [SerializeField] private float m_GravityMultiplier;
+
+        [SerializeField] public MouseLook m_MouseLook;
+
+        [SerializeField] private bool m_UseFovKick;
+
+        [SerializeField] private FOVKick m_FovKick = new FOVKick();
+
+        [SerializeField] private bool m_UseHeadBob;
+
+        [SerializeField] private CurveControlledBob m_HeadBob = new CurveControlledBob();
+
+        [SerializeField] private LerpControlledBob m_JumpBob = new LerpControlledBob();
+
+        [SerializeField] private float m_StepInterval;
+
+        [SerializeField] private AudioClip[] m_FootstepSounds;
+
+        [SerializeField] private AudioClip[] m_FootstepSoundsBridge;
+
+        [SerializeField] private AudioClip[] m_FootstepSoundsStone;
+
+        [SerializeField] private AudioClip m_JumpSound;
+
+        [SerializeField] private AudioClip m_LandSound;
+
+        private Camera m_Camera;
+
+        private bool m_Jump;
+
+        public bool frezzeRotation;
+
+        public bool frezzePosition;
+
+        public bool rotateMouseInFixedUpdate = true;
+
+        public Vector2 m_Input;
+
+        public Vector3 m_MoveDir = Vector3.zero;
+
+        public CharacterController m_CharacterController;
+
+        private CollisionFlags m_CollisionFlags;
+
+        private bool m_PreviouslyGrounded;
+
+        private Vector3 m_OriginalCameraPosition;
+
+        private float m_StepCycle;
+
+        private float m_NextStep;
+
+        private bool m_Jumping;
+
+        private AudioSource m_AudioSource;
+
+        private string groundTypeTag = "";
+
+        public float horizontal;
+
+        public float vertical;
+
+        public bool isJumping;
+
+        public bool isRuning;
+
+        public bool notMove;
+
+        public bool isWater;
+
+        private void Start()
+        {
+            m_CharacterController = GetComponent<CharacterController>();
+            m_Camera = Camera.main;
+            m_OriginalCameraPosition = m_Camera.transform.localPosition;
+            m_FovKick.Setup(m_Camera);
+            m_HeadBob.Setup(m_Camera, m_StepInterval);
+            m_StepCycle = 0f;
+            m_NextStep = m_StepCycle / 2f;
+            m_Jumping = false;
+            m_AudioSource = GetComponent<AudioSource>();
+            m_MouseLook.Init(transform, m_Camera.transform);
+        }
+
+        private void Update()
+        {
+            if (!frezzeRotation && !rotateMouseInFixedUpdate)
+            {
+                RotateView();
+            }
+
+            if (!m_Jump)
+            {
+                m_Jump = isJumping;
+            }
+
+            if (!m_PreviouslyGrounded && m_CharacterController.isGrounded)
+            {
+                StartCoroutine(m_JumpBob.DoBobCycle());
+                PlayLandingSound();
+                m_MoveDir.y = 0f;
+                m_Jumping = false;
+            }
+
+            if (!m_CharacterController.isGrounded && !m_Jumping && m_PreviouslyGrounded)
+            {
+                m_MoveDir.y = 0f;
+            }
+
+            m_PreviouslyGrounded = m_CharacterController.isGrounded;
+        }
+
+        private void PlayLandingSound()
+        {
+            m_AudioSource.clip = m_LandSound;
+            m_AudioSource.Play();
+            m_NextStep = m_StepCycle + 0.5f;
+        }
+
+        private void FixedUpdate()
+        {
+            if (!frezzeRotation && rotateMouseInFixedUpdate)
+            {
+                RotateView();
+            }
+
+            if (frezzePosition)
+            {
+                return;
+            }
+
+            GetInput(out var speed);
+            Vector3 vector = transform.forward * m_Input.y + transform.right * m_Input.x;
+            Physics.SphereCast(transform.position, m_CharacterController.radius, Vector3.down, out var hitInfo,
+                m_CharacterController.height / 2f, -1, QueryTriggerInteraction.Ignore);
+            vector = Vector3.ProjectOnPlane(vector, hitInfo.normal).normalized;
+            m_MoveDir.x = vector.x * speed;
+            m_MoveDir.z = vector.z * speed;
+            if (m_CharacterController.isGrounded)
+            {
+                m_MoveDir.y = 0f - m_StickToGroundForce;
+                if (m_Jump && !isWater)
+                {
+                    if ((bool)transform.parent && transform.parent.gameObject.layer == LayerMask.NameToLayer("Boat"))
+                    {
+                        return;
+                    }
+
+                    m_MoveDir.y = m_JumpSpeed;
+                    PlayJumpSound();
+                    m_Jump = false;
+                    m_Jumping = true;
+                }
+            }
+            else
+            {
+                m_MoveDir += Physics.gravity * m_GravityMultiplier * Time.fixedDeltaTime;
+            }
+
+            if (!notMove)
+            {
+                m_CollisionFlags = m_CharacterController.Move(m_MoveDir * Time.fixedDeltaTime);
+            }
+
+            ProgressStepCycle(speed);
+            UpdateCameraPosition(speed);
+            m_MouseLook.UpdateCursorLock();
+        }
+
+        private void PlayJumpSound()
+        {
+            m_AudioSource.clip = m_JumpSound;
+            m_AudioSource.Play();
+        }
+
+        private void ProgressStepCycle(float speed)
+        {
+            if (m_CharacterController.velocity.sqrMagnitude > 0f && (m_Input.x != 0f || m_Input.y != 0f))
+            {
+                m_StepCycle +=
+                    (m_CharacterController.velocity.magnitude + speed * (m_IsWalking ? 1f : m_RunstepLenghten)) *
+                    Time.fixedDeltaTime;
+            }
+
+            if (m_StepCycle > m_NextStep)
+            {
+                m_NextStep = m_StepCycle + m_StepInterval;
+                PlayFootStepAudio();
+            }
+        }
+
+        private void PlayFootStepAudio()
+        {
+            if (!m_CharacterController.isGrounded)
+            {
+                return;
+            }
+
+            if (groundTypeTag == "Bridge" || groundTypeTag == "Boat")
+            {
+                if (m_FootstepSoundsBridge.Length != 0)
+                {
+                    int num = Random.Range(1, m_FootstepSoundsBridge.Length);
+                    m_AudioSource.clip = m_FootstepSoundsBridge[num];
+                    m_AudioSource.PlayOneShot(m_AudioSource.clip, 0.3f);
+                    m_FootstepSoundsBridge[num] = m_FootstepSoundsBridge[0];
+                    m_FootstepSoundsBridge[0] = m_AudioSource.clip;
+                }
+            }
+            else if (groundTypeTag == "Stone")
+            {
+                if (m_FootstepSoundsStone.Length != 0)
+                {
+                    int num2 = Random.Range(1, m_FootstepSoundsStone.Length);
+                    m_AudioSource.clip = m_FootstepSoundsStone[num2];
+                    m_AudioSource.PlayOneShot(m_AudioSource.clip, 0.3f);
+                    m_FootstepSoundsStone[num2] = m_FootstepSoundsStone[0];
+                    m_FootstepSoundsStone[0] = m_AudioSource.clip;
+                }
+            }
+            else if (m_FootstepSounds.Length != 0)
+            {
+                int num3 = Random.Range(1, m_FootstepSounds.Length);
+                m_AudioSource.clip = m_FootstepSounds[num3];
+                m_AudioSource.PlayOneShot(m_AudioSource.clip, 0.3f);
+                m_FootstepSounds[num3] = m_FootstepSounds[0];
+                m_FootstepSounds[0] = m_AudioSource.clip;
+            }
+        }
+
+        private void UpdateCameraPosition(float speed)
+        {
+            if (m_UseHeadBob)
+            {
+                Vector3 localPosition;
+                if (m_CharacterController.velocity.magnitude > 0f && m_CharacterController.isGrounded)
+                {
+                    m_Camera.transform.localPosition = m_HeadBob.DoHeadBob(m_CharacterController.velocity.magnitude +
+                                                                           speed *
+                                                                           (m_IsWalking ? 1f : m_RunstepLenghten));
+                    localPosition = m_Camera.transform.localPosition;
+                    localPosition.y = m_Camera.transform.localPosition.y - m_JumpBob.Offset();
+                }
+                else
+                {
+                    localPosition = m_Camera.transform.localPosition;
+                    localPosition.y = m_OriginalCameraPosition.y - m_JumpBob.Offset();
+                }
+
+                m_Camera.transform.localPosition = localPosition;
+            }
+        }
+
+        private void GetInput(out float speed)
+        {
+            bool isWalking = m_IsWalking;
+            m_IsWalking = !isRuning;
+            speed = (m_IsWalking ? m_WalkSpeed : m_RunSpeed);
+            m_Input = new Vector2(horizontal, vertical);
+            if (m_Input.sqrMagnitude > 1f)
+            {
+                m_Input.Normalize();
+            }
+
+            if (m_IsWalking != isWalking && m_UseFovKick && m_CharacterController.velocity.sqrMagnitude > 0f)
+            {
+                StopAllCoroutines();
+                StartCoroutine((!m_IsWalking) ? m_FovKick.FOVKickUp() : m_FovKick.FOVKickDown());
+            }
+        }
+
+        public void RotateView()
+        {
+            m_MouseLook.LookRotation(transform, m_Camera.transform);
+        }
+        
+        private void OnControllerColliderHit(ControllerColliderHit hit)
+        {
+            Rigidbody attachedRigidbody = hit.collider.attachedRigidbody;
+            groundTypeTag = hit.collider.tag;
+
+            if (m_CollisionFlags != CollisionFlags.Below && !(attachedRigidbody == null))
+            {
+                _ = attachedRigidbody.isKinematic;
+            }
+        }
+
+        private void OnTriggerStay(Collider other)
+        {
+            if (other.CompareTag("Water"))
+            {
+                isWater = true;
+            }
+        }
+
+        private void OnTriggerExit(Collider other)
+        {
+            if (other.CompareTag("Water"))
+            {
+                isWater = false;
+            }
+        }
+    }
+}

Assets/Scripts/FirstPersonController/FirstPersonController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2f1324aa5e564035ab9a361499a66c27
+timeCreated: 1748446121

Assets/Scripts/FirstPersonController/MouseLook.cs

@@ -0,0 +1,132 @@
+using System;
+using UnityEngine;
+
+namespace NBF
+{
+    [Serializable]
+    public class MouseLook
+    {
+        public float XSensitivity = 2f;
+
+        public float YSensitivity = 2f;
+
+        public bool clampVerticalRotation = true;
+
+        public float MinimumX = -90f;
+
+        public float MaximumX = 90f;
+
+        public bool smooth;
+
+        public float smoothTime = 5f;
+
+        public bool lockCursor = true;
+
+        public float RotYvalue;
+
+        public bool invertMouseY;
+
+        public bool invertMouseX;
+
+        public int ControllerHandMode;
+
+        private Quaternion m_CharacterTargetRot;
+
+        private Quaternion m_CameraTargetRot;
+
+        private bool m_cursorIsLocked = true;
+
+        // private Player player;
+
+        public void Init(Transform character, Transform camera)
+        {
+            m_CharacterTargetRot = character.localRotation;
+            m_CameraTargetRot = camera.localRotation;
+            // player = ReInput.players.GetPlayer(0);
+        }
+
+        public void LookRotation(Transform character, Transform camera)
+        {
+            // if (!SRDebug.Instance.IsDebugPanelVisible && !SRDebug.Instance.IsDebugPanelVisible)
+            {
+                var lookInput = InputManager.GetLookInput();
+
+                float num = Mathf.Clamp(lookInput.y * YSensitivity * 5f * Time.deltaTime, -10f, 10f);
+                float num2 =
+                    Mathf.Clamp(lookInput.x * XSensitivity * 5f * Time.deltaTime, -10f, 10f);
+
+                if (invertMouseY)
+                {
+                    num *= -1f;
+                }
+
+                if (invertMouseX)
+                {
+                    num2 *= -1f;
+                }
+
+                RotYvalue = num2;
+                m_CharacterTargetRot *= Quaternion.Euler(0f, num2, 0f);
+                m_CameraTargetRot *= Quaternion.Euler(0f - num, 0f, 0f);
+                if (clampVerticalRotation)
+                {
+                    m_CameraTargetRot = ClampRotationAroundXAxis(m_CameraTargetRot);
+                }
+
+                if (smooth)
+                {
+                    character.localRotation = Quaternion.Slerp(character.localRotation, m_CharacterTargetRot,
+                        smoothTime * Time.deltaTime);
+                    camera.localRotation = Quaternion.Slerp(camera.localRotation, m_CameraTargetRot,
+                        smoothTime * Time.deltaTime);
+                }
+                else
+                {
+                    character.localRotation = m_CharacterTargetRot;
+                    camera.localRotation = m_CameraTargetRot;
+                }
+
+                UpdateCursorLock();
+            }
+        }
+
+        public void SetCursorLock(bool value)
+        {
+            lockCursor = value;
+            if (!lockCursor)
+            {
+                Cursor.lockState = CursorLockMode.None;
+                Cursor.visible = true;
+            }
+            else
+            {
+                Cursor.lockState = CursorLockMode.Locked;
+                Cursor.visible = false;
+            }
+        }
+
+        public void UpdateCursorLock()
+        {
+            if (lockCursor)
+            {
+                InternalLockUpdate();
+            }
+        }
+
+        private void InternalLockUpdate()
+        {
+        }
+
+        private Quaternion ClampRotationAroundXAxis(Quaternion q)
+        {
+            q.x /= q.w;
+            q.y /= q.w;
+            q.z /= q.w;
+            q.w = 1f;
+            float value = 114.59156f * Mathf.Atan(q.x);
+            value = Mathf.Clamp(value, MinimumX, MaximumX);
+            q.x = Mathf.Tan((float)Math.PI / 360f * value);
+            return q;
+        }
+    }
+}

Assets/Scripts/FirstPersonController/MouseLook.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8d0cbae98ed8408e90ca0cb0e05b6d1d
+timeCreated: 1748446245

Assets/Scripts/FirstPersonController/Utility.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8d919912beb546df866a283a379c7e96
+timeCreated: 1748446174

Assets/Scripts/FirstPersonController/Utility/CurveControlledBob.cs

@@ -0,0 +1,54 @@
+using System;
+using UnityEngine;
+
+namespace NBF
+{
+    [Serializable]
+    public class CurveControlledBob
+    {
+        public float HorizontalBobRange = 0.33f;
+
+        public float VerticalBobRange = 0.33f;
+
+        public AnimationCurve Bobcurve = new AnimationCurve(new Keyframe(0f, 0f), new Keyframe(0.5f, 1f),
+            new Keyframe(1f, 0f), new Keyframe(1.5f, -1f), new Keyframe(2f, 0f));
+
+        public float VerticaltoHorizontalRatio = 1f;
+
+        private float m_CyclePositionX;
+
+        private float m_CyclePositionY;
+
+        private float m_BobBaseInterval;
+
+        private Vector3 m_OriginalCameraPosition;
+
+        private float m_Time;
+
+        public void Setup(Camera camera, float bobBaseInterval)
+        {
+            m_BobBaseInterval = bobBaseInterval;
+            m_OriginalCameraPosition = camera.transform.localPosition;
+            m_Time = Bobcurve[Bobcurve.length - 1].time;
+        }
+
+        public Vector3 DoHeadBob(float speed)
+        {
+            float x = m_OriginalCameraPosition.x + Bobcurve.Evaluate(m_CyclePositionX) * HorizontalBobRange;
+            float y = m_OriginalCameraPosition.y + Bobcurve.Evaluate(m_CyclePositionY) * VerticalBobRange;
+            m_CyclePositionX += speed * Time.deltaTime / m_BobBaseInterval;
+            m_CyclePositionY += speed * Time.deltaTime / m_BobBaseInterval * VerticaltoHorizontalRatio;
+            if (m_CyclePositionX > m_Time)
+            {
+                m_CyclePositionX -= m_Time;
+            }
+
+            if (m_CyclePositionY > m_Time)
+            {
+                m_CyclePositionY -= m_Time;
+            }
+
+            return new Vector3(x, y, 0f);
+        }
+    }
+}

Assets/Scripts/FirstPersonController/Utility/CurveControlledBob.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 491f525f09d84899a13bf70f08f7a713
+timeCreated: 1748446274

Assets/Scripts/FirstPersonController/Utility/FOVKick.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace NBF
+{
+    [Serializable]
+    public class FOVKick
+    {
+        public Camera Camera;
+
+        [HideInInspector] public float originalFov;
+
+        public float FOVIncrease = 3f;
+
+        public float TimeToIncrease = 1f;
+
+        public float TimeToDecrease = 1f;
+
+        public AnimationCurve IncreaseCurve;
+
+        public void Setup(Camera camera)
+        {
+            CheckStatus(camera);
+            Camera = camera;
+            originalFov = camera.fieldOfView;
+        }
+
+        private void CheckStatus(Camera camera)
+        {
+            if (camera == null)
+            {
+                throw new Exception("FOVKick camera is null, please supply the camera to the constructor");
+            }
+
+            if (IncreaseCurve == null)
+            {
+                throw new Exception(
+                    "FOVKick Increase curve is null, please define the curve for the field of view kicks");
+            }
+        }
+
+        public void ChangeCamera(Camera camera)
+        {
+            Camera = camera;
+        }
+
+        public IEnumerator FOVKickUp()
+        {
+            float t = Mathf.Abs((Camera.fieldOfView - originalFov) / FOVIncrease);
+            while (t < TimeToIncrease)
+            {
+                Camera.fieldOfView = originalFov + IncreaseCurve.Evaluate(t / TimeToIncrease) * FOVIncrease;
+                t += Time.deltaTime;
+                yield return new WaitForEndOfFrame();
+            }
+        }
+
+        public IEnumerator FOVKickDown()
+        {
+            float t = Mathf.Abs((Camera.fieldOfView - originalFov) / FOVIncrease);
+            while (t > 0f)
+            {
+                Camera.fieldOfView = originalFov + IncreaseCurve.Evaluate(t / TimeToDecrease) * FOVIncrease;
+                t -= Time.deltaTime;
+                yield return new WaitForEndOfFrame();
+            }
+
+            Camera.fieldOfView = originalFov;
+        }
+    }
+}

Assets/Scripts/FirstPersonController/Utility/FOVKick.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cb6289c553a943a98adf26c14b1eaf2b
+timeCreated: 1748446181

Assets/Scripts/FirstPersonController/Utility/LerpControlledBob.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace NBF
+{
+    [Serializable]
+    public class LerpControlledBob
+    {
+        public float BobDuration;
+
+        public float BobAmount;
+
+        private float m_Offset;
+
+        public float Offset()
+        {
+            return m_Offset;
+        }
+
+        public IEnumerator DoBobCycle()
+        {
+            float t2 = 0f;
+            while (t2 < BobDuration)
+            {
+                m_Offset = Mathf.Lerp(0f, BobAmount, t2 / BobDuration);
+                t2 += Time.deltaTime;
+                yield return new WaitForFixedUpdate();
+            }
+            t2 = 0f;
+            while (t2 < BobDuration)
+            {
+                m_Offset = Mathf.Lerp(BobAmount, 0f, t2 / BobDuration);
+                t2 += Time.deltaTime;
+                yield return new WaitForFixedUpdate();
+            }
+            m_Offset = 0f;
+        }
+    }
+}

Assets/Scripts/FirstPersonController/Utility/LerpControlledBob.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1ff17b813690432a9da59c9ab3ceccbb
+timeCreated: 1748446293