Game/Fishing2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改FPS控制

Browse Source
This commit is contained in:
BobSong
2025-05-28 23:45:19 +08:00
parent 8e7afd9ea1
commit cdcb007d6d
18 changed files with 1012 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Assets/Scripts/FirstPersonController.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 19ffa462a8ae4066a12d946a8b80cab0
timeCreated: 1748446110

324
Assets/Scripts/FirstPersonController/FirstPersonController.cs Normal file
View File

@@ -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;
}
}
}
}

3
Assets/Scripts/FirstPersonController/FirstPersonController.cs.meta Normal file
View File

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

132
Assets/Scripts/FirstPersonController/MouseLook.cs Normal file
View File

@@ -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;
}
}
}

3
Assets/Scripts/FirstPersonController/MouseLook.cs.meta Normal file
View File

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

3
Assets/Scripts/FirstPersonController/Utility.meta Normal file
View File

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

54
Assets/Scripts/FirstPersonController/Utility/CurveControlledBob.cs Normal file
View File

@@ -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);
}
}
}

3
Assets/Scripts/FirstPersonController/Utility/CurveControlledBob.cs.meta Normal file
View File

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

72
Assets/Scripts/FirstPersonController/Utility/FOVKick.cs Normal file
View File

@@ -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;
}
}
}

3
Assets/Scripts/FirstPersonController/Utility/FOVKick.cs.meta Normal file
View File

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

40
Assets/Scripts/FirstPersonController/Utility/LerpControlledBob.cs Normal file
View File

@@ -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;
}
}
}

3
Assets/Scripts/FirstPersonController/Utility/LerpControlledBob.cs.meta Normal file
View File

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

3
Assets/Scripts/Fishing/Player/FPlayer.cs
View File

@@ -37,7 +37,7 @@ public partial class FPlayer : MonoBehaviour
public CapsuleCollider Collider;
public Rigidbody Rigidbody;
private void Awake()
{
PlayerAnimatorCtrl = gameObject.GetComponent<PlayerAnimator>();
@@ -77,6 +77,7 @@ public partial class FPlayer : MonoBehaviour
if (data.PlayerID == GameModel.RoleID)
{
Fishing.Inst.Player.SelfPlayer = this;
var mainSync = gameObject.AddComponent<FPlayerMainSync>();
BaseCamera.Main.transform.SetParent(CameraRoot);
BaseCamera.Main.transform.localPosition = Vector3.zero;
}

143
Assets/Scripts/Fishing/Player/PlayerCharacter/FPlayerMainSync.cs Normal file
View File

@@ -0,0 +1,143 @@
using NBC;
using UnityEngine;
namespace NBF
{
public class FPlayerMainSync : MonoBehaviour
{
public FirstPersonController firstPersonController;
[HideInInspector] public int nextShowSlotIndex = -1;
private float walkingSpeed = 1f;
private float runningSpeed = 2f;
private FPlayer _player;
private bool _isRun;
private void Start()
{
firstPersonController = GetComponent<FirstPersonController>();
walkingSpeed = firstPersonController.m_WalkSpeed;
runningSpeed = firstPersonController.m_RunSpeed;
_player = GetComponent<FPlayer>();
transform.position = _player.Data.position;
transform.rotation = _player.Data.rotation;
Timer.Once(1f, this, EnableFirstPersonController);
// App.Inst.SetMouseCurrsor(false);
// InputManager.OnQuickIndexAction += OnQuickIndexAction;
// InputManager.OnUseTorchAction += OnUseTorchAction;
// InputManager.OnUseTelescopeAction += OnUseTelescopeAction;
InputManager.OnPlayerCanceled += OnPlayerCanceled;
InputManager.OnPlayerPerformed += OnPlayerPerformed;
}
private void OnDestroy()
{
InputManager.OnPlayerCanceled -= OnPlayerCanceled;
InputManager.OnPlayerPerformed -= OnPlayerPerformed;
// InputManager.OnQuickIndexAction -= OnQuickIndexAction;
// InputManager.OnUseTorchAction -= OnUseTorchAction;
// InputManager.OnUseTelescopeAction -= OnUseTelescopeAction;
}
private void OnPlayerPerformed(string action)
{
if (action == "Run")
{
// Sprint();
_isRun = true;
}
}
private void OnPlayerCanceled(string action)
{
if (action == "Run")
{
_isRun = false;
// StopSprinting();
}
else if (action.StartsWith("Quick"))
{
nextShowSlotIndex = int.Parse(action.Substring("Quick".Length));
}
else if (action == "UseTorch")
{
_player.Data.openLight = !_player.Data.openLight;
}
else if (action == "UseTelescope")
{
_player.Data.openTelescope = !_player.Data.openTelescope;
_player.ToggleTelescope();
}
}
private void EnableFirstPersonController()
{
firstPersonController.enabled = true;
}
private void Update()
{
var movementAxis = InputManager.GetMovementInput();
if (movementAxis != Vector2.zero)
{
// Debug
}
firstPersonController.horizontal = movementAxis.x;
firstPersonController.vertical = movementAxis.y;
// firstPersonController.isJumping = InputManager.IsJumping;
firstPersonController.isRuning = _isRun;
// firstPersonController.m_MouseLook.ControllerHandMode = GameManager.Instance._playerData
// .Player[GameManager.Instance._playerData.currentPlayerProfileIndex].controllerSetup;
if (firstPersonController.isWater)
{
firstPersonController.m_WalkSpeed = walkingSpeed - Mathf.Abs(transform.position.y - 1f);
firstPersonController.m_RunSpeed = firstPersonController.m_WalkSpeed;
firstPersonController.m_WalkSpeed = Mathf.Clamp(firstPersonController.m_WalkSpeed, 0.7f, 2f);
firstPersonController.m_RunSpeed = Mathf.Clamp(firstPersonController.m_RunSpeed, 0.8f, 2f);
}
else
{
firstPersonController.m_WalkSpeed = walkingSpeed;
firstPersonController.m_RunSpeed = runningSpeed;
}
if (_player.CanChangeGear())
{
if (nextShowSlotIndex > 0)
{
Debug.LogError("切换钓组=========");
var data = Fishing.Inst.Datasource;
data.SetSelfTestGear(nextShowSlotIndex);
nextShowSlotIndex = -1;
}
}
}
private void FixedUpdate()
{
if (_player.MainArm)
{
// _player.MainArm.Shoulder.SetCameraEulerAngleX(BaseCamera.Main.transform.localEulerAngles.x);
}
}
}
}

3
Assets/Scripts/Fishing/Player/PlayerCharacter/FPlayerMainSync.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 5cf18b87277f477ab6a9b59759ee17cb
timeCreated: 1748446764