686 lines
21 KiB
C#
686 lines
21 KiB
C#
using UnityEngine;
|
||
|
||
namespace NBF
|
||
{
|
||
public enum FishingBobberControlMode
|
||
{
|
||
AirPhysics,
|
||
WaterPresentation,
|
||
}
|
||
|
||
public enum FishingBobberBiteType
|
||
{
|
||
None,
|
||
Tap,
|
||
SlowSink,
|
||
Lift,
|
||
BlackDrift,
|
||
}
|
||
|
||
public enum BobberTiltAxis
|
||
{
|
||
LocalX,
|
||
LocalZ,
|
||
}
|
||
|
||
[DisallowMultipleComponent]
|
||
[RequireComponent(typeof(Rigidbody))]
|
||
public class FishingBobberFeature : FishingLineNodeMotionFeature
|
||
{
|
||
protected override int DefaultPriority => 100;
|
||
|
||
#region 检测入水
|
||
|
||
[Header("入水检测")]
|
||
[Tooltip("当前测试阶段固定水面高度。")]
|
||
public float waterLevel = 0f;
|
||
|
||
[Tooltip("浮漂底部进入水面达到该深度后，切换为水面表现控制。")]
|
||
public float enterWaterDepth = 0.002f;
|
||
|
||
[Tooltip("浮漂底部高于该深度时退出水面表现控制。通常设为负值用于滞回。")]
|
||
public float exitWaterDepth = -0.01f;
|
||
|
||
[Tooltip("浮漂总高度，单位米。")]
|
||
public float floatHeight = 0.08f;
|
||
|
||
[Tooltip("如果 Pivot 在浮漂底部填 0；如果 Pivot 在模型中部，填底部相对 Pivot 的本地 Y 偏移。")]
|
||
public float bottomOffsetLocalY;
|
||
|
||
[Tooltip("Y 轴控制的平滑时间。")]
|
||
public float ySmoothTime = 0.08f;
|
||
|
||
[Tooltip("Y 轴平滑时允许的最大竖直速度。")]
|
||
public float maxYSpeed = 2f;
|
||
|
||
[Tooltip("Y 轴死区，小范围内直接贴目标值以减少微抖。")]
|
||
public float yDeadZone = 0.0005f;
|
||
|
||
#endregion
|
||
|
||
#region 吃水控制
|
||
|
||
[Header("吃水控制")]
|
||
[Tooltip("基准底部重量。当前重量等于该值时，使用基础吃水深度。")]
|
||
public float neutralBottomWeight = 1f;
|
||
|
||
[Tooltip("当前底部总重量。运行时可由其他脚本更新。")]
|
||
public float currentBottomWeight = 1f;
|
||
|
||
[Tooltip("基准重量下的基础吃水深度。")]
|
||
public float baseDraftDepth = 0.02f;
|
||
|
||
[Tooltip("每单位重量变化对应增加或减少的吃水深度。")]
|
||
public float draftDepthPerWeight = 0.01f;
|
||
|
||
[Tooltip("吃水深度下限。")]
|
||
public float minDraftDepth = 0.005f;
|
||
|
||
[Tooltip("吃水深度上限。")]
|
||
public float maxDraftDepth = 0.08f;
|
||
|
||
[Tooltip("吃水深度变化的平滑时间。")]
|
||
public float draftSmoothTime = 0.18f;
|
||
|
||
#endregion
|
||
|
||
#region 漂相动画
|
||
|
||
[Header("漂相动画")]
|
||
[Tooltip("漂相位移动画的平滑时间。")]
|
||
public float biteSmoothTime = 0.03f;
|
||
|
||
[Tooltip("点漂默认振幅。")]
|
||
public float tapAmplitude = 0.008f;
|
||
|
||
[Tooltip("点漂默认时长。")]
|
||
public float tapDuration = 0.18f;
|
||
|
||
[Tooltip("缓沉默认振幅。")]
|
||
public float slowSinkAmplitude = 0.025f;
|
||
|
||
[Tooltip("缓沉默认时长。")]
|
||
public float slowSinkDuration = 1.2f;
|
||
|
||
[Tooltip("顶漂默认振幅。")]
|
||
public float liftAmplitude = 0.015f;
|
||
|
||
[Tooltip("顶漂默认时长。")]
|
||
public float liftDuration = 1.2f;
|
||
|
||
[Tooltip("黑漂默认振幅。")]
|
||
public float blackDriftAmplitude = 0.06f;
|
||
|
||
[Tooltip("黑漂默认时长。")]
|
||
public float blackDriftDuration = 0.8f;
|
||
|
||
#endregion
|
||
|
||
#region 输入测试
|
||
|
||
[Header("输入测试")]
|
||
[Tooltip("是否启用运行时按键测试漂相。")]
|
||
public bool enableDebugInput = true;
|
||
|
||
[Tooltip("停止当前漂相的按键。")]
|
||
public KeyCode stopBiteKey = KeyCode.R;
|
||
|
||
[Tooltip("触发点漂的按键。")]
|
||
public KeyCode tapKey = KeyCode.T;
|
||
|
||
[Tooltip("触发缓沉的按键。")]
|
||
public KeyCode slowSinkKey = KeyCode.G;
|
||
|
||
[Tooltip("触发顶漂的按键。")]
|
||
public KeyCode liftKey = KeyCode.H;
|
||
|
||
[Tooltip("触发黑漂的按键。")]
|
||
public KeyCode blackDriftKey = KeyCode.B;
|
||
|
||
#endregion
|
||
|
||
#region 姿态控制
|
||
|
||
[Header("姿态控制")]
|
||
[Tooltip("重量低于该值时，姿态趋向躺漂。")]
|
||
public float lyingWeightThreshold = 0.4f;
|
||
|
||
[Tooltip("重量达到该值附近时，姿态趋向半躺。")]
|
||
public float tiltedWeightThreshold = 0.8f;
|
||
|
||
[Tooltip("重量达到该值及以上时，姿态趋向立漂。")]
|
||
public float uprightWeightThreshold = 1.2f;
|
||
|
||
[Tooltip("躺漂对应的倾角。")]
|
||
public float lyingAngle = 88f;
|
||
|
||
[Tooltip("半躺对应的倾角。")]
|
||
public float tiltedAngle = 42f;
|
||
|
||
[Tooltip("立漂对应的倾角，通常为 0。")]
|
||
public float uprightAngle = 0f;
|
||
|
||
[Tooltip("绕哪个本地轴做倾倒。")]
|
||
public BobberTiltAxis tiltAxis = BobberTiltAxis.LocalX;
|
||
|
||
[Tooltip("是否反转倾倒方向。")]
|
||
public bool invertTiltDirection;
|
||
|
||
[Tooltip("姿态旋转的平滑速度。")]
|
||
public float rotationLerpSpeed = 8f;
|
||
|
||
[Tooltip("入水后用于压制旋转抖动的角阻尼。")]
|
||
public float waterAngularDamping = 999f;
|
||
|
||
#endregion
|
||
|
||
#region 运行时状态
|
||
|
||
public FishingBobberControlMode CurrentMode => _mode;
|
||
public FishingBobberBiteType CurrentBiteType => _activeBiteType;
|
||
public float CurrentDraftDepth => _currentDraftDepth;
|
||
public float CurrentBottomWeight => currentBottomWeight;
|
||
|
||
private Rigidbody _rb;
|
||
private FishingBobberControlMode _mode = FishingBobberControlMode.AirPhysics;
|
||
|
||
private bool _defaultsCached;
|
||
private bool _waterStateInitialized;
|
||
private float _defaultAngularDamping;
|
||
private bool _defaultUseGravity;
|
||
private RigidbodyConstraints _defaultConstraints;
|
||
|
||
private float _draftVelocity;
|
||
private float _currentDraftDepth;
|
||
private float _ySmoothVelocity;
|
||
private float _biteOffsetY;
|
||
private float _biteOffsetYVelocity;
|
||
|
||
private bool _uprightPoseCached;
|
||
private Quaternion _cachedUprightRotation;
|
||
private Quaternion _uprightReferenceRotation;
|
||
private Quaternion _targetRotation;
|
||
|
||
private FishingBobberBiteType _activeBiteType = FishingBobberBiteType.None;
|
||
private float _biteTimer;
|
||
private float _biteDuration;
|
||
private float _biteAmplitude;
|
||
|
||
#endregion
|
||
|
||
#region Unity 生命周期
|
||
|
||
private void Awake()
|
||
{
|
||
EnsureRuntimeReferences();
|
||
InitializeRuntimeState();
|
||
}
|
||
|
||
private void Update()
|
||
{
|
||
HandleDebugInput();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 运动控制接入
|
||
|
||
public override bool IsSupportedNode(FishingLineNode node)
|
||
{
|
||
return node != null && node.Type == FishingLineNode.NodeType.Float;
|
||
}
|
||
|
||
protected override void OnBind()
|
||
{
|
||
EnsureRuntimeReferences();
|
||
InitializeRuntimeState();
|
||
}
|
||
|
||
public override bool CanControl()
|
||
{
|
||
EnsureRuntimeReferences();
|
||
if (_rb == null || !IsSupportedNode(Node))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var submergeDepth = GetSubmergeDepth();
|
||
if (_mode == FishingBobberControlMode.WaterPresentation)
|
||
{
|
||
return submergeDepth >= exitWaterDepth;
|
||
}
|
||
|
||
return submergeDepth > enterWaterDepth;
|
||
}
|
||
|
||
public override void OnMotionActivated()
|
||
{
|
||
EnsureRuntimeReferences();
|
||
EnterWaterPresentationMode();
|
||
}
|
||
|
||
public override void OnMotionDeactivated()
|
||
{
|
||
EnsureRuntimeReferences();
|
||
ExitWaterPresentationMode();
|
||
}
|
||
|
||
public override void TickMotion(float deltaTime)
|
||
{
|
||
EnsureRuntimeReferences();
|
||
if (_rb == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var submergeDepth = GetSubmergeDepth();
|
||
if (submergeDepth < exitWaterDepth)
|
||
{
|
||
ExitWaterPresentationMode();
|
||
return;
|
||
}
|
||
|
||
if (_mode != FishingBobberControlMode.WaterPresentation)
|
||
{
|
||
EnterWaterPresentationMode();
|
||
}
|
||
|
||
UpdateBiteAnimation(deltaTime);
|
||
UpdateDraft(deltaTime);
|
||
var nextRotation = CalculateNextRotation(deltaTime);
|
||
UpdateVerticalPosition(deltaTime, nextRotation);
|
||
ApplyRotation(nextRotation);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 漂相接口
|
||
|
||
public void SetBottomWeight(float weight)
|
||
{
|
||
currentBottomWeight = weight;
|
||
}
|
||
|
||
public void PlayTap(float amplitude = -1f, float duration = -1f)
|
||
{
|
||
StartBite(
|
||
FishingBobberBiteType.Tap,
|
||
amplitude > 0f ? amplitude : tapAmplitude,
|
||
duration > 0f ? duration : tapDuration);
|
||
}
|
||
|
||
public void PlaySlowSink(float amplitude = -1f, float duration = -1f)
|
||
{
|
||
StartBite(
|
||
FishingBobberBiteType.SlowSink,
|
||
amplitude > 0f ? amplitude : slowSinkAmplitude,
|
||
duration > 0f ? duration : slowSinkDuration);
|
||
}
|
||
|
||
public void PlayLift(float amplitude = -1f, float duration = -1f)
|
||
{
|
||
StartBite(
|
||
FishingBobberBiteType.Lift,
|
||
amplitude > 0f ? amplitude : liftAmplitude,
|
||
duration > 0f ? duration : liftDuration);
|
||
}
|
||
|
||
public void PlayBlackDrift(float amplitude = -1f, float duration = -1f)
|
||
{
|
||
StartBite(
|
||
FishingBobberBiteType.BlackDrift,
|
||
amplitude > 0f ? amplitude : blackDriftAmplitude,
|
||
duration > 0f ? duration : blackDriftDuration);
|
||
}
|
||
|
||
public void StopBite()
|
||
{
|
||
_activeBiteType = FishingBobberBiteType.None;
|
||
_biteTimer = 0f;
|
||
_biteDuration = 0f;
|
||
_biteAmplitude = 0f;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 内部实现
|
||
|
||
private void EnsureRuntimeReferences()
|
||
{
|
||
if (_rb == null)
|
||
{
|
||
_rb = Node != null && Node.Body != null ? Node.Body : GetComponent<Rigidbody>();
|
||
}
|
||
}
|
||
|
||
private void InitializeRuntimeState()
|
||
{
|
||
if (_rb == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!_defaultsCached)
|
||
{
|
||
_defaultAngularDamping = _rb.angularDamping;
|
||
_defaultUseGravity = _rb.useGravity;
|
||
_defaultConstraints = _rb.constraints;
|
||
_defaultsCached = true;
|
||
}
|
||
|
||
_currentDraftDepth = CalculateRawDraftDepth();
|
||
_draftVelocity = 0f;
|
||
_ySmoothVelocity = 0f;
|
||
_biteOffsetY = 0f;
|
||
_biteOffsetYVelocity = 0f;
|
||
_targetRotation = _rb.rotation;
|
||
|
||
if (!_uprightPoseCached)
|
||
{
|
||
_cachedUprightRotation = _rb.rotation;
|
||
_uprightPoseCached = true;
|
||
}
|
||
|
||
_uprightReferenceRotation = _cachedUprightRotation;
|
||
}
|
||
|
||
private void EnterWaterPresentationMode()
|
||
{
|
||
if (_rb == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_mode = FishingBobberControlMode.WaterPresentation;
|
||
_waterStateInitialized = true;
|
||
_uprightReferenceRotation = _cachedUprightRotation;
|
||
_targetRotation = _rb.rotation;
|
||
_draftVelocity = 0f;
|
||
_ySmoothVelocity = 0f;
|
||
_biteOffsetYVelocity = 0f;
|
||
_currentDraftDepth = CalculateRawDraftDepth();
|
||
|
||
_rb.useGravity = false;
|
||
_rb.angularDamping = waterAngularDamping;
|
||
_rb.constraints = _defaultConstraints | RigidbodyConstraints.FreezeRotation;
|
||
_rb.angularVelocity = Vector3.zero;
|
||
}
|
||
|
||
private void ExitWaterPresentationMode()
|
||
{
|
||
_mode = FishingBobberControlMode.AirPhysics;
|
||
RestorePhysicsState();
|
||
}
|
||
|
||
private void RestorePhysicsState()
|
||
{
|
||
if (_rb == null || !_defaultsCached)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_rb.useGravity = _defaultUseGravity;
|
||
_rb.angularDamping = _defaultAngularDamping;
|
||
_rb.constraints = _defaultConstraints;
|
||
}
|
||
|
||
private float GetSubmergeDepth()
|
||
{
|
||
return waterLevel - GetBottomWorldPosition().y;
|
||
}
|
||
|
||
private Vector3 GetBottomWorldPosition()
|
||
{
|
||
return transform.TransformPoint(new Vector3(0f, bottomOffsetLocalY, 0f));
|
||
}
|
||
|
||
private float CalculateRawDraftDepth()
|
||
{
|
||
var weightDelta = currentBottomWeight - neutralBottomWeight;
|
||
var targetDraft = baseDraftDepth + weightDelta * draftDepthPerWeight;
|
||
return Mathf.Clamp(targetDraft, minDraftDepth, maxDraftDepth);
|
||
}
|
||
|
||
private void UpdateDraft(float deltaTime)
|
||
{
|
||
var targetDraft = CalculateRawDraftDepth();
|
||
_currentDraftDepth = Mathf.SmoothDamp(
|
||
_currentDraftDepth,
|
||
targetDraft,
|
||
ref _draftVelocity,
|
||
Mathf.Max(0.0001f, draftSmoothTime),
|
||
Mathf.Infinity,
|
||
deltaTime);
|
||
}
|
||
|
||
private void UpdateVerticalPosition(float deltaTime, Quaternion targetRotation)
|
||
{
|
||
var position = _rb.position;
|
||
var targetY = waterLevel - _currentDraftDepth - GetBottomOffsetWorldY(targetRotation) + _biteOffsetY;
|
||
|
||
if (Mathf.Abs(position.y - targetY) < yDeadZone)
|
||
{
|
||
position.y = targetY;
|
||
_ySmoothVelocity = 0f;
|
||
}
|
||
else
|
||
{
|
||
position.y = Mathf.SmoothDamp(
|
||
position.y,
|
||
targetY,
|
||
ref _ySmoothVelocity,
|
||
Mathf.Max(0.0001f, ySmoothTime),
|
||
maxYSpeed,
|
||
deltaTime);
|
||
}
|
||
|
||
_rb.MovePosition(position);
|
||
|
||
var velocity = _rb.linearVelocity;
|
||
if (Mathf.Abs(velocity.y) > 0f)
|
||
{
|
||
velocity.y = 0f;
|
||
_rb.linearVelocity = velocity;
|
||
}
|
||
}
|
||
|
||
private Quaternion CalculateNextRotation(float deltaTime)
|
||
{
|
||
var targetTiltAngle = EvaluateTargetTiltAngle();
|
||
var signedAngle = invertTiltDirection ? -targetTiltAngle : targetTiltAngle;
|
||
var localAxis = tiltAxis == BobberTiltAxis.LocalX ? Vector3.right : Vector3.forward;
|
||
|
||
_targetRotation = _uprightReferenceRotation * Quaternion.AngleAxis(signedAngle, localAxis);
|
||
_rb.angularVelocity = Vector3.zero;
|
||
return Quaternion.Slerp(
|
||
_rb.rotation,
|
||
_targetRotation,
|
||
1f - Mathf.Exp(-Mathf.Max(0.01f, rotationLerpSpeed) * deltaTime));
|
||
}
|
||
|
||
private void ApplyRotation(Quaternion nextRotation)
|
||
{
|
||
_rb.rotation = nextRotation;
|
||
}
|
||
|
||
private float GetBottomOffsetWorldY(Quaternion rotation)
|
||
{
|
||
return (rotation * new Vector3(0f, bottomOffsetLocalY, 0f)).y;
|
||
}
|
||
|
||
private float EvaluateTargetTiltAngle()
|
||
{
|
||
if (currentBottomWeight <= lyingWeightThreshold)
|
||
{
|
||
return lyingAngle;
|
||
}
|
||
|
||
if (currentBottomWeight <= tiltedWeightThreshold)
|
||
{
|
||
var t = Mathf.InverseLerp(lyingWeightThreshold, tiltedWeightThreshold, currentBottomWeight);
|
||
return Mathf.Lerp(lyingAngle, tiltedAngle, t);
|
||
}
|
||
|
||
if (currentBottomWeight <= uprightWeightThreshold)
|
||
{
|
||
var t = Mathf.InverseLerp(tiltedWeightThreshold, uprightWeightThreshold, currentBottomWeight);
|
||
return Mathf.Lerp(tiltedAngle, uprightAngle, t);
|
||
}
|
||
|
||
return uprightAngle;
|
||
}
|
||
|
||
private void StartBite(FishingBobberBiteType type, float amplitude, float duration)
|
||
{
|
||
if (_mode != FishingBobberControlMode.WaterPresentation)
|
||
{
|
||
return;
|
||
}
|
||
|
||
_activeBiteType = type;
|
||
_biteTimer = 0f;
|
||
_biteDuration = Mathf.Max(0.01f, duration);
|
||
_biteAmplitude = Mathf.Max(0f, amplitude);
|
||
_biteOffsetYVelocity = 0f;
|
||
}
|
||
|
||
private void UpdateBiteAnimation(float deltaTime)
|
||
{
|
||
if (_activeBiteType == FishingBobberBiteType.None)
|
||
{
|
||
_biteOffsetY = Mathf.SmoothDamp(
|
||
_biteOffsetY,
|
||
0f,
|
||
ref _biteOffsetYVelocity,
|
||
Mathf.Max(0.0001f, biteSmoothTime),
|
||
Mathf.Infinity,
|
||
deltaTime);
|
||
return;
|
||
}
|
||
|
||
_biteTimer += deltaTime;
|
||
var t = Mathf.Clamp01(_biteTimer / _biteDuration);
|
||
var targetOffset = 0f;
|
||
|
||
switch (_activeBiteType)
|
||
{
|
||
case FishingBobberBiteType.Tap:
|
||
if (t < 0.35f)
|
||
{
|
||
var downT = t / 0.35f;
|
||
targetOffset = -Mathf.SmoothStep(0f, _biteAmplitude, downT);
|
||
}
|
||
else
|
||
{
|
||
var upT = (t - 0.35f) / 0.65f;
|
||
targetOffset = -Mathf.Lerp(_biteAmplitude, 0f, upT);
|
||
}
|
||
break;
|
||
|
||
case FishingBobberBiteType.SlowSink:
|
||
targetOffset = -Mathf.SmoothStep(0f, _biteAmplitude, t);
|
||
break;
|
||
|
||
case FishingBobberBiteType.Lift:
|
||
targetOffset = Mathf.SmoothStep(0f, _biteAmplitude, t);
|
||
break;
|
||
|
||
case FishingBobberBiteType.BlackDrift:
|
||
targetOffset = -Mathf.SmoothStep(0f, _biteAmplitude, t);
|
||
break;
|
||
}
|
||
|
||
_biteOffsetY = Mathf.SmoothDamp(
|
||
_biteOffsetY,
|
||
targetOffset,
|
||
ref _biteOffsetYVelocity,
|
||
Mathf.Max(0.0001f, biteSmoothTime),
|
||
Mathf.Infinity,
|
||
deltaTime);
|
||
|
||
if (_biteTimer >= _biteDuration &&
|
||
_activeBiteType != FishingBobberBiteType.SlowSink &&
|
||
_activeBiteType != FishingBobberBiteType.BlackDrift)
|
||
{
|
||
_activeBiteType = FishingBobberBiteType.None;
|
||
}
|
||
}
|
||
|
||
private void HandleDebugInput()
|
||
{
|
||
if (!Application.isPlaying || !enableDebugInput)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (Input.GetKeyDown(stopBiteKey))
|
||
{
|
||
StopBite();
|
||
}
|
||
|
||
if (Input.GetKeyDown(tapKey))
|
||
{
|
||
PlayTap();
|
||
}
|
||
|
||
if (Input.GetKeyDown(slowSinkKey))
|
||
{
|
||
PlaySlowSink();
|
||
}
|
||
|
||
if (Input.GetKeyDown(liftKey))
|
||
{
|
||
PlayLift();
|
||
}
|
||
|
||
if (Input.GetKeyDown(blackDriftKey))
|
||
{
|
||
PlayBlackDrift();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 参数校验
|
||
|
||
#if UNITY_EDITOR
|
||
private void OnValidate()
|
||
{
|
||
floatHeight = Mathf.Max(0.001f, floatHeight);
|
||
ySmoothTime = Mathf.Max(0.001f, ySmoothTime);
|
||
maxYSpeed = Mathf.Max(0.01f, maxYSpeed);
|
||
yDeadZone = Mathf.Max(0f, yDeadZone);
|
||
|
||
neutralBottomWeight = Mathf.Max(0f, neutralBottomWeight);
|
||
currentBottomWeight = Mathf.Max(0f, currentBottomWeight);
|
||
minDraftDepth = Mathf.Max(0f, minDraftDepth);
|
||
maxDraftDepth = Mathf.Max(minDraftDepth, maxDraftDepth);
|
||
baseDraftDepth = Mathf.Clamp(baseDraftDepth, minDraftDepth, maxDraftDepth);
|
||
draftDepthPerWeight = Mathf.Max(0f, draftDepthPerWeight);
|
||
draftSmoothTime = Mathf.Max(0.001f, draftSmoothTime);
|
||
|
||
biteSmoothTime = Mathf.Max(0.001f, biteSmoothTime);
|
||
tapAmplitude = Mathf.Max(0f, tapAmplitude);
|
||
tapDuration = Mathf.Max(0.01f, tapDuration);
|
||
slowSinkAmplitude = Mathf.Max(0f, slowSinkAmplitude);
|
||
slowSinkDuration = Mathf.Max(0.01f, slowSinkDuration);
|
||
liftAmplitude = Mathf.Max(0f, liftAmplitude);
|
||
liftDuration = Mathf.Max(0.01f, liftDuration);
|
||
blackDriftAmplitude = Mathf.Max(0f, blackDriftAmplitude);
|
||
blackDriftDuration = Mathf.Max(0.01f, blackDriftDuration);
|
||
|
||
lyingWeightThreshold = Mathf.Max(0f, lyingWeightThreshold);
|
||
tiltedWeightThreshold = Mathf.Max(lyingWeightThreshold, tiltedWeightThreshold);
|
||
uprightWeightThreshold = Mathf.Max(tiltedWeightThreshold, uprightWeightThreshold);
|
||
uprightAngle = Mathf.Clamp(uprightAngle, 0f, 89f);
|
||
tiltedAngle = Mathf.Clamp(tiltedAngle, uprightAngle, 89f);
|
||
lyingAngle = Mathf.Clamp(lyingAngle, tiltedAngle, 89.9f);
|
||
rotationLerpSpeed = Mathf.Max(0.01f, rotationLerpSpeed);
|
||
waterAngularDamping = Mathf.Max(0f, waterAngularDamping);
|
||
}
|
||
#endif
|
||
|
||
#endregion
|
||
}
|
||
}
|