961 lines
31 KiB
C#
961 lines
31 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Text;
|
||
using UnityEngine;
|
||
|
||
namespace NBF
|
||
{
|
||
public enum LineType
|
||
{
|
||
Hand,
|
||
HandDouble,
|
||
Spinning,
|
||
SpinningFloat,
|
||
}
|
||
|
||
public class FishingLineSolver : FGearBase
|
||
{
|
||
[Serializable]
|
||
public sealed class ChainPoint
|
||
{
|
||
public long Key;
|
||
public Vector3 Position;
|
||
public bool IsLogical;
|
||
public FishingLineNode LogicalNode;
|
||
public int SegmentIndex;
|
||
public int StableIndex;
|
||
|
||
public string GetDebugName()
|
||
{
|
||
if (IsLogical)
|
||
{
|
||
return LogicalNode != null ? LogicalNode.GetDebugName() : $"L[{StableIndex}]";
|
||
}
|
||
|
||
return $"V[S{SegmentIndex}:{StableIndex}]";
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
private struct SegmentLayout
|
||
{
|
||
public float[] GapLengths;
|
||
|
||
public int VirtualNodeCount => Mathf.Max(0, GapLengths.Length - 1);
|
||
}
|
||
|
||
|
||
[SerializeField] public LineType LineType;
|
||
|
||
[Header("References")] [SerializeField]
|
||
private Transform anchorTransform;
|
||
|
||
[SerializeField] private FishingLineNode[] logicalNodes = Array.Empty<FishingLineNode>();
|
||
[SerializeField] private FishingLineRenderer lineRenderer;
|
||
|
||
[Header("First Segment")] [Min(0f)] [SerializeField]
|
||
private float firstSegmentLength = 1.2f;
|
||
|
||
[Min(0.001f)] [SerializeField] private float firstSegmentStep = 0.1f;
|
||
|
||
[Header("Joint")] [Min(1)] [SerializeField]
|
||
private int jointSolverIterations = 12;
|
||
|
||
[SerializeField] private float jointProjectionDistance = 0.02f;
|
||
[SerializeField] private float jointProjectionAngle = 1f;
|
||
|
||
[Header("Limit Detection")]
|
||
[Min(0f)]
|
||
// 极限判定的长度容差，允许链路在总长或单段长度上存在少量误差。
|
||
[SerializeField]
|
||
private float lengthLimitTolerance = 0.01f;
|
||
|
||
[Min(0f)]
|
||
// 达到极限后，只有当前超长值大于该阈值时，才开始进入断线候选计时。
|
||
[SerializeField]
|
||
private float breakStretchThreshold = 0.05f;
|
||
|
||
[Min(0f)]
|
||
// 断线候选状态允许持续的最大时间；超过后会发出一次断线消息。
|
||
[SerializeField]
|
||
private float breakLimitDuration = 0.15f;
|
||
|
||
[Header("Runtime Debug")] [SerializeField]
|
||
private bool autoBuildOnStart = true;
|
||
|
||
private readonly List<ChainPoint> chainPoints = new();
|
||
private readonly List<float> restLengths = new();
|
||
private readonly List<int> pinnedIndices = new();
|
||
private readonly List<ConfigurableJoint> runtimeJoints = new();
|
||
|
||
private bool chainDirty = true;
|
||
private int runtimeVirtualPointCount;
|
||
|
||
public float FirstSegmentLength => firstSegmentLength;
|
||
|
||
public float FirstSegmentStep => firstSegmentStep;
|
||
|
||
public IReadOnlyList<ChainPoint> ChainPoints => chainPoints;
|
||
|
||
public IReadOnlyList<float> RestLengths => restLengths;
|
||
|
||
public IReadOnlyList<int> PinnedIndices => pinnedIndices;
|
||
|
||
/// <summary>
|
||
/// 当前配置的逻辑节点只读列表。
|
||
/// 外部可读取节点顺序，但不应直接修改数组内容。
|
||
/// </summary>
|
||
public IReadOnlyList<FishingLineNode> LogicalNodes => logicalNodes;
|
||
|
||
/// <summary>
|
||
/// 当前整条鱼线的配置总长度，等于所有段的静止长度之和。
|
||
/// </summary>
|
||
public float TotalLineLength { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前逻辑节点链路的实际总长度，按相邻逻辑节点的实际距离累加。
|
||
/// </summary>
|
||
public float CurrentLogicalChainLength { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前首尾逻辑节点之间的直线距离，仅作为端点跨度观察值。
|
||
/// </summary>
|
||
public float CurrentEndpointDistance { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前逻辑链总长度超出配置总长度的部分，小于等于零时记为 0。
|
||
/// </summary>
|
||
public float CurrentStretchLength { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前所有逻辑段中，单段超出配置长度的最大值。
|
||
/// </summary>
|
||
public float MaxSegmentStretchLength { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前超限最明显的逻辑段索引；为 -1 表示没有段处于超限。
|
||
/// </summary>
|
||
public int MaxOverstretchedSegmentIndex { get; private set; } = -1;
|
||
|
||
/// <summary>
|
||
/// 当前受拉比例。
|
||
/// 该值取“单段实际长度 / 单段配置长度”和“整链实际长度 / 整链配置长度”中的最大值。
|
||
/// 约等于 1 表示接近拉直，大于 1 表示已经出现超限拉伸。
|
||
/// </summary>
|
||
public float CurrentTensionRatio { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 断线候选拉伸阈值。
|
||
/// 只有当前处于极限状态，且超长值大于该阈值时，才会开始累计断线计时。
|
||
/// </summary>
|
||
public float BreakStretchThreshold => breakStretchThreshold;
|
||
|
||
/// <summary>
|
||
/// 断线候选状态可持续的最大时间。
|
||
/// 当断线计时超过该值时，会发出一次断线消息。
|
||
/// </summary>
|
||
public float BreakLimitDuration => breakLimitDuration;
|
||
|
||
/// <summary>
|
||
/// 当前拉力极限百分比。
|
||
/// 当超长值小于等于 lengthLimitTolerance 时为 0；
|
||
/// 当超长值大于等于 breakStretchThreshold 时为 100；
|
||
/// 中间区间按线性比例映射，供 UI 显示使用。
|
||
/// </summary>
|
||
public float CurrentBreakStretchPercent => EvaluateBreakStretchPercent(CurrentStretchLength);
|
||
|
||
/// <summary>
|
||
/// 当前是否处于极限状态。
|
||
/// 只要整链超出总长度容差，或任一逻辑段超出单段容差，即认为到达极限。
|
||
/// </summary>
|
||
public bool IsAtLimit { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前断线候选状态的累计时间。
|
||
/// 只有在处于极限状态，且 CurrentStretchLength 大于断线阈值时才会累加；否则重置为 0。
|
||
/// </summary>
|
||
public float LimitStateTime { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当前是否正在进行断线候选计时。
|
||
/// </summary>
|
||
public bool IsBreakCountdownActive => IsAtLimit && CurrentStretchLength > breakStretchThreshold;
|
||
|
||
/// <summary>
|
||
/// 当前极限断线消息是否已经发出过。
|
||
/// 在退出断线候选状态前只会发一次，避免重复通知。
|
||
/// </summary>
|
||
public bool HasBreakNotificationSent { get; private set; }
|
||
|
||
/// <summary>
|
||
/// 当鱼线达到断线条件时发出的一次性消息。
|
||
/// 外部可订阅该事件，在回调中执行切线、播放表现或状态切换。
|
||
/// </summary>
|
||
public event Action<FishingLineSolver> OnLineBreakRequested;
|
||
|
||
public int LogicalNodeCount => logicalNodes?.Length ?? 0;
|
||
|
||
public int RuntimeVirtualNodeCount => runtimeVirtualPointCount;
|
||
|
||
public int ActiveRuntimeVirtualNodeCount => runtimeVirtualPointCount;
|
||
|
||
public int OrderedNodeCount => chainPoints.Count;
|
||
|
||
public int SegmentCount => restLengths.Count;
|
||
|
||
public bool IsChainDirty => chainDirty;
|
||
|
||
private void Reset()
|
||
{
|
||
if (lineRenderer == null)
|
||
{
|
||
TryGetComponent(out lineRenderer);
|
||
}
|
||
}
|
||
|
||
protected override void OnInit()
|
||
{
|
||
var tipRb = Rod.Asset.LineConnectorRigidbody;
|
||
anchorTransform = tipRb.transform;
|
||
}
|
||
|
||
private void Start()
|
||
{
|
||
if (autoBuildOnStart)
|
||
{
|
||
BuildLine();
|
||
}
|
||
}
|
||
|
||
private void FixedUpdate()
|
||
{
|
||
if (logicalNodes == null || logicalNodes.Length == 0)
|
||
{
|
||
ResetLimitState();
|
||
return;
|
||
}
|
||
|
||
UpdateAnchorNode();
|
||
|
||
if (chainDirty)
|
||
{
|
||
RebuildRuntimeChain();
|
||
}
|
||
|
||
EvaluateLimitState(Time.fixedDeltaTime);
|
||
}
|
||
|
||
private void LateUpdate()
|
||
{
|
||
if (chainDirty)
|
||
{
|
||
RebuildRuntimeChain();
|
||
}
|
||
|
||
SyncLogicalPointPositions();
|
||
|
||
if (lineRenderer != null && chainPoints.Count > 1)
|
||
{
|
||
lineRenderer.Render(this, Time.deltaTime);
|
||
}
|
||
}
|
||
|
||
private void OnValidate()
|
||
{
|
||
firstSegmentLength = Mathf.Max(0f, firstSegmentLength);
|
||
firstSegmentStep = Mathf.Max(0.001f, firstSegmentStep);
|
||
jointSolverIterations = Mathf.Max(1, jointSolverIterations);
|
||
lengthLimitTolerance = Mathf.Max(0f, lengthLimitTolerance);
|
||
breakStretchThreshold = Mathf.Max(0f, breakStretchThreshold);
|
||
breakLimitDuration = Mathf.Max(0f, breakLimitDuration);
|
||
chainDirty = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 按当前配置重建整条鱼线的运行时链路，并立即刷新极限状态。
|
||
/// </summary>
|
||
[ContextMenu("Build Line")]
|
||
public void BuildLine()
|
||
{
|
||
ConfigureStartNode();
|
||
ConfigureLogicalJoints();
|
||
RebuildRuntimeChain();
|
||
EvaluateLimitState(0f);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置指定逻辑段的配置长度。
|
||
/// segmentIndex 为 0 时表示第一段；大于 0 时表示对应逻辑节点到下一个逻辑节点的线长。
|
||
/// </summary>
|
||
public void SetLenght(float length, int segmentIndex = 0)
|
||
{
|
||
var clamped = Mathf.Max(0f, length);
|
||
var currentLength = GetSegmentLength(segmentIndex);
|
||
if (Mathf.Approximately(clamped, currentLength))
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (segmentIndex <= 0)
|
||
{
|
||
firstSegmentLength = clamped;
|
||
}
|
||
else
|
||
{
|
||
if (logicalNodes == null || segmentIndex >= logicalNodes.Length)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var sourceNode = logicalNodes[segmentIndex];
|
||
if (sourceNode == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
sourceNode.SegmentLengthToNext = clamped;
|
||
}
|
||
|
||
UpdateJointLimit(segmentIndex + 1, clamped);
|
||
chainDirty = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 立即按当前配置重建鱼线。
|
||
/// </summary>
|
||
public void RebuildNow()
|
||
{
|
||
BuildLine();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据类型获取逻辑节点类型
|
||
/// </summary>
|
||
/// <param name="nodeType"></param>
|
||
/// <returns></returns>
|
||
public FishingLineNode GetLogicalNode(FishingLineNode.NodeType nodeType)
|
||
{
|
||
foreach (var fishingLineNode in logicalNodes)
|
||
{
|
||
if (fishingLineNode.Type == nodeType)
|
||
{
|
||
return fishingLineNode;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
// /// <summary>
|
||
// /// 获取指定顺序索引的逻辑节点。
|
||
// /// 索引基于 logicalNodes 配置顺序；超出范围或节点为空时返回 null。
|
||
// /// </summary>
|
||
// public FishingLineNode GetLogicalNode(int logicalIndex)
|
||
// {
|
||
// if (logicalNodes == null || logicalIndex < 0 || logicalIndex >= logicalNodes.Length)
|
||
// {
|
||
// return null;
|
||
// }
|
||
//
|
||
// return logicalNodes[logicalIndex];
|
||
// }
|
||
//
|
||
// /// <summary>
|
||
// /// 尝试获取指定顺序索引的逻辑节点。
|
||
// /// 获取失败时返回 false，并将 node 置为 null。
|
||
// /// </summary>
|
||
// public bool TryGetLogicalNode(int logicalIndex, out FishingLineNode node)
|
||
// {
|
||
// node = GetLogicalNode(logicalIndex);
|
||
// return node != null;
|
||
// }
|
||
|
||
/// <summary>
|
||
/// 获取当前起点逻辑节点。
|
||
/// 会返回配置顺序中第一个非空节点。
|
||
/// </summary>
|
||
public FishingLineNode GetStartNode()
|
||
{
|
||
return FindFirstValidLogicalNode();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取当前终点逻辑节点。
|
||
/// 会返回配置顺序中最后一个非空节点。
|
||
/// </summary>
|
||
public FishingLineNode GetEndNode()
|
||
{
|
||
return FindLastValidLogicalNode();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取当前运行时链路中相邻采样点的实际距离。
|
||
/// 这里的采样点包含逻辑节点和虚拟节点。
|
||
/// </summary>
|
||
public float GetActualDistance(int segmentIndex)
|
||
{
|
||
if (segmentIndex < 0 || segmentIndex >= chainPoints.Count - 1)
|
||
{
|
||
return 0f;
|
||
}
|
||
|
||
return Vector3.Distance(chainPoints[segmentIndex].Position, chainPoints[segmentIndex + 1].Position);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 返回当前鱼线运行时调试摘要，包含链路结构、长度和极限状态信息。
|
||
/// </summary>
|
||
public string GetRuntimeDebugSummary()
|
||
{
|
||
var builder = new StringBuilder(512);
|
||
builder.Append("chain:")
|
||
.Append(chainDirty ? "dirty" : "ready")
|
||
.Append(" logical:")
|
||
.Append(LogicalNodeCount)
|
||
.Append(" runtimeVirtual:")
|
||
.Append(RuntimeVirtualNodeCount)
|
||
.Append(" ordered:")
|
||
.Append(OrderedNodeCount)
|
||
.Append(" total:")
|
||
.Append(TotalLineLength.ToString("F2"))
|
||
.Append("m")
|
||
.Append(" chain:")
|
||
.Append(CurrentLogicalChainLength.ToString("F2"))
|
||
.Append("m")
|
||
.Append(" tension:")
|
||
.Append(CurrentTensionRatio.ToString("F3"))
|
||
.Append(" breakPercent:")
|
||
.Append(CurrentBreakStretchPercent.ToString("F1"))
|
||
.Append('%')
|
||
.Append(" limit:")
|
||
.Append(IsAtLimit ? "yes" : "no")
|
||
.Append(" limitTime:")
|
||
.Append(LimitStateTime.ToString("F2"))
|
||
.Append("s");
|
||
|
||
for (var i = 0; i < chainPoints.Count; i++)
|
||
{
|
||
var point = chainPoints[i];
|
||
builder.AppendLine()
|
||
.Append('#')
|
||
.Append(i)
|
||
.Append(' ')
|
||
.Append(point.GetDebugName())
|
||
.Append(" pos:")
|
||
.Append(point.Position);
|
||
|
||
if (point.IsLogical && point.LogicalNode != null)
|
||
{
|
||
builder.Append(" body:")
|
||
.Append(point.LogicalNode.Body != null ? "yes" : "no");
|
||
}
|
||
|
||
if (i < restLengths.Count)
|
||
{
|
||
builder.Append(" seg rest:")
|
||
.Append(restLengths[i].ToString("F3"))
|
||
.Append(" actual:")
|
||
.Append(GetActualDistance(i).ToString("F3"));
|
||
}
|
||
}
|
||
|
||
return builder.ToString();
|
||
}
|
||
|
||
private void ConfigureStartNode()
|
||
{
|
||
if (logicalNodes == null || logicalNodes.Length == 0 || logicalNodes[0] == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var startNode = logicalNodes[0];
|
||
startNode.Type = FishingLineNode.NodeType.Start;
|
||
|
||
if (startNode.Body != null)
|
||
{
|
||
startNode.Body.isKinematic = true;
|
||
startNode.Body.interpolation = RigidbodyInterpolation.Interpolate;
|
||
startNode.Body.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
|
||
}
|
||
|
||
UpdateAnchorNode();
|
||
}
|
||
|
||
private void ConfigureLogicalJoints()
|
||
{
|
||
runtimeJoints.Clear();
|
||
|
||
if (logicalNodes == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (var i = 1; i < logicalNodes.Length; i++)
|
||
{
|
||
var current = logicalNodes[i];
|
||
var previous = logicalNodes[i - 1];
|
||
if (current == null || previous == null || current.Body == null || previous.Body == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
current.Body.solverIterations = jointSolverIterations;
|
||
current.Body.interpolation = RigidbodyInterpolation.Interpolate;
|
||
current.Body.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
|
||
|
||
var joint = current.GetComponent<ConfigurableJoint>();
|
||
if (joint == null)
|
||
{
|
||
joint = current.gameObject.AddComponent<ConfigurableJoint>();
|
||
}
|
||
|
||
joint.autoConfigureConnectedAnchor = true;
|
||
joint.connectedBody = previous.Body;
|
||
joint.xMotion = ConfigurableJointMotion.Limited;
|
||
joint.yMotion = ConfigurableJointMotion.Limited;
|
||
joint.zMotion = ConfigurableJointMotion.Limited;
|
||
joint.angularXMotion = ConfigurableJointMotion.Free;
|
||
joint.angularYMotion = ConfigurableJointMotion.Free;
|
||
joint.angularZMotion = ConfigurableJointMotion.Free;
|
||
joint.projectionMode = JointProjectionMode.PositionAndRotation;
|
||
joint.projectionDistance = jointProjectionDistance;
|
||
joint.projectionAngle = jointProjectionAngle;
|
||
|
||
var limit = joint.linearLimit;
|
||
limit.limit = GetSegmentLength(i - 1);
|
||
joint.linearLimit = limit;
|
||
|
||
runtimeJoints.Add(joint);
|
||
}
|
||
}
|
||
|
||
private void UpdateAnchorNode()
|
||
{
|
||
if (anchorTransform == null || logicalNodes == null || logicalNodes.Length == 0 || logicalNodes[0] == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var startNode = logicalNodes[0];
|
||
startNode.transform.SetPositionAndRotation(anchorTransform.position, anchorTransform.rotation);
|
||
|
||
if (startNode.Body != null)
|
||
{
|
||
if (!startNode.Body.isKinematic)
|
||
{
|
||
startNode.Body.linearVelocity = Vector3.zero;
|
||
startNode.Body.angularVelocity = Vector3.zero;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void EvaluateLimitState(float deltaTime)
|
||
{
|
||
CurrentLogicalChainLength = 0f;
|
||
CurrentEndpointDistance = 0f;
|
||
CurrentStretchLength = 0f;
|
||
MaxSegmentStretchLength = 0f;
|
||
MaxOverstretchedSegmentIndex = -1;
|
||
CurrentTensionRatio = 0f;
|
||
|
||
if (logicalNodes == null || logicalNodes.Length < 2)
|
||
{
|
||
SetLimitState(false);
|
||
UpdateBreakCountdown(deltaTime);
|
||
return;
|
||
}
|
||
|
||
FishingLineNode firstNode = null;
|
||
FishingLineNode lastNode = null;
|
||
|
||
for (var segmentIndex = 0; segmentIndex < logicalNodes.Length; segmentIndex++)
|
||
{
|
||
var node = logicalNodes[segmentIndex];
|
||
if (node == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
firstNode ??= node;
|
||
lastNode = node;
|
||
|
||
if (segmentIndex >= logicalNodes.Length - 1)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var nextNode = logicalNodes[segmentIndex + 1];
|
||
if (nextNode == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var actualDistance = Vector3.Distance(node.Position, nextNode.Position);
|
||
var configuredLength = GetSegmentLength(segmentIndex);
|
||
CurrentLogicalChainLength += actualDistance;
|
||
|
||
if (configuredLength > 0.0001f)
|
||
{
|
||
CurrentTensionRatio = Mathf.Max(CurrentTensionRatio, actualDistance / configuredLength);
|
||
}
|
||
|
||
var segmentStretchLength = Mathf.Max(0f, actualDistance - configuredLength);
|
||
if (segmentStretchLength > MaxSegmentStretchLength)
|
||
{
|
||
MaxSegmentStretchLength = segmentStretchLength;
|
||
MaxOverstretchedSegmentIndex = segmentStretchLength > 0f ? segmentIndex : -1;
|
||
}
|
||
}
|
||
|
||
if (firstNode != null && lastNode != null && !ReferenceEquals(firstNode, lastNode))
|
||
{
|
||
CurrentEndpointDistance = Vector3.Distance(firstNode.Position, lastNode.Position);
|
||
}
|
||
|
||
if (TotalLineLength > 0.0001f)
|
||
{
|
||
CurrentStretchLength = Mathf.Max(0f, CurrentLogicalChainLength - TotalLineLength);
|
||
CurrentTensionRatio = Mathf.Max(CurrentTensionRatio, CurrentLogicalChainLength / TotalLineLength);
|
||
}
|
||
else if (CurrentLogicalChainLength > 0f)
|
||
{
|
||
CurrentStretchLength = CurrentLogicalChainLength;
|
||
CurrentTensionRatio = Mathf.Max(CurrentTensionRatio, 1f);
|
||
}
|
||
|
||
var exceedsTotalLength = CurrentStretchLength > lengthLimitTolerance;
|
||
var exceedsSegmentLength = MaxSegmentStretchLength > lengthLimitTolerance;
|
||
SetLimitState(exceedsTotalLength || exceedsSegmentLength);
|
||
UpdateBreakCountdown(deltaTime);
|
||
}
|
||
|
||
private void SetLimitState(bool isAtLimit)
|
||
{
|
||
IsAtLimit = isAtLimit;
|
||
}
|
||
|
||
private void UpdateBreakCountdown(float deltaTime)
|
||
{
|
||
if (!IsBreakCountdownActive)
|
||
{
|
||
LimitStateTime = 0f;
|
||
HasBreakNotificationSent = false;
|
||
return;
|
||
}
|
||
|
||
LimitStateTime += Mathf.Max(0f, deltaTime);
|
||
|
||
if (HasBreakNotificationSent || LimitStateTime < breakLimitDuration)
|
||
{
|
||
return;
|
||
}
|
||
|
||
HasBreakNotificationSent = true;
|
||
NotifyLineBreakRequested();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 发出鱼线达到断线条件的消息。
|
||
/// 这里预留给外部订阅，当前不在求解器内部直接执行断线逻辑。
|
||
/// </summary>
|
||
private void NotifyLineBreakRequested()
|
||
{
|
||
OnLineBreakRequested?.Invoke(this);
|
||
}
|
||
|
||
private void ResetLimitState()
|
||
{
|
||
CurrentLogicalChainLength = 0f;
|
||
CurrentEndpointDistance = 0f;
|
||
CurrentStretchLength = 0f;
|
||
MaxSegmentStretchLength = 0f;
|
||
MaxOverstretchedSegmentIndex = -1;
|
||
CurrentTensionRatio = 0f;
|
||
IsAtLimit = false;
|
||
LimitStateTime = 0f;
|
||
HasBreakNotificationSent = false;
|
||
}
|
||
|
||
private float EvaluateBreakStretchPercent(float stretchLength)
|
||
{
|
||
if (stretchLength <= lengthLimitTolerance)
|
||
{
|
||
return 0f;
|
||
}
|
||
|
||
if (stretchLength >= breakStretchThreshold)
|
||
{
|
||
return 100f;
|
||
}
|
||
|
||
if (breakStretchThreshold <= lengthLimitTolerance)
|
||
{
|
||
return 100f;
|
||
}
|
||
|
||
return Mathf.InverseLerp(lengthLimitTolerance, breakStretchThreshold, stretchLength) * 100f;
|
||
}
|
||
|
||
private void RebuildRuntimeChain()
|
||
{
|
||
chainPoints.Clear();
|
||
restLengths.Clear();
|
||
pinnedIndices.Clear();
|
||
TotalLineLength = 0f;
|
||
runtimeVirtualPointCount = 0;
|
||
|
||
if (logicalNodes == null || logicalNodes.Length < 2)
|
||
{
|
||
chainDirty = false;
|
||
return;
|
||
}
|
||
|
||
var segmentLayouts = new SegmentLayout[logicalNodes.Length - 1];
|
||
for (var segmentIndex = 0; segmentIndex < segmentLayouts.Length; segmentIndex++)
|
||
{
|
||
segmentLayouts[segmentIndex] = BuildSegmentLayout(segmentIndex);
|
||
}
|
||
|
||
AddLogicalPoint(logicalNodes[0], 0);
|
||
pinnedIndices.Add(0);
|
||
|
||
for (var segmentIndex = 0; segmentIndex < segmentLayouts.Length; segmentIndex++)
|
||
{
|
||
var fromNode = logicalNodes[segmentIndex];
|
||
var toNode = logicalNodes[segmentIndex + 1];
|
||
if (fromNode == null || toNode == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var layout = segmentLayouts[segmentIndex];
|
||
AddVirtualPoints(fromNode.Position, toNode.Position, layout, segmentIndex);
|
||
|
||
for (var gapIndex = 0; gapIndex < layout.GapLengths.Length; gapIndex++)
|
||
{
|
||
restLengths.Add(layout.GapLengths[gapIndex]);
|
||
TotalLineLength += layout.GapLengths[gapIndex];
|
||
}
|
||
|
||
AddLogicalPoint(toNode, segmentIndex + 1);
|
||
pinnedIndices.Add(chainPoints.Count - 1);
|
||
}
|
||
|
||
chainDirty = false;
|
||
}
|
||
|
||
private SegmentLayout BuildSegmentLayout(int segmentIndex)
|
||
{
|
||
var totalLength = GetSegmentLength(segmentIndex);
|
||
if (segmentIndex == 0)
|
||
{
|
||
return new SegmentLayout
|
||
{
|
||
GapLengths = BuildFirstSegmentGaps(totalLength, firstSegmentStep),
|
||
};
|
||
}
|
||
|
||
var sourceNode = logicalNodes[segmentIndex];
|
||
var virtualCount = sourceNode != null ? sourceNode.FixedVirtualNodesToNext : 0;
|
||
var gapCount = Mathf.Max(1, virtualCount + 1);
|
||
var gapLength = totalLength / gapCount;
|
||
var gaps = new float[gapCount];
|
||
for (var i = 0; i < gaps.Length; i++)
|
||
{
|
||
gaps[i] = gapLength;
|
||
}
|
||
|
||
return new SegmentLayout
|
||
{
|
||
GapLengths = gaps,
|
||
};
|
||
}
|
||
|
||
private void AddLogicalPoint(FishingLineNode logicalNode, int logicalIndex)
|
||
{
|
||
if (logicalNode == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
chainPoints.Add(new ChainPoint
|
||
{
|
||
Key = BuildLogicalPointKey(logicalIndex),
|
||
Position = logicalNode.Position,
|
||
IsLogical = true,
|
||
LogicalNode = logicalNode,
|
||
SegmentIndex = logicalIndex,
|
||
StableIndex = logicalIndex,
|
||
});
|
||
}
|
||
|
||
private void AddVirtualPoints(Vector3 fromPosition, Vector3 toPosition, SegmentLayout layout, int segmentIndex)
|
||
{
|
||
if (layout.VirtualNodeCount == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var direction = toPosition - fromPosition;
|
||
var distance = direction.magnitude;
|
||
var normalizedDirection = distance > 0.0001f ? direction / distance : Vector3.down;
|
||
var accumulatedDistance = 0f;
|
||
|
||
for (var virtualIndex = 0; virtualIndex < layout.VirtualNodeCount; virtualIndex++)
|
||
{
|
||
accumulatedDistance += layout.GapLengths[virtualIndex];
|
||
var stableIndex = segmentIndex == 0
|
||
? layout.VirtualNodeCount - 1 - virtualIndex
|
||
: virtualIndex;
|
||
|
||
chainPoints.Add(new ChainPoint
|
||
{
|
||
Key = BuildVirtualPointKey(segmentIndex, stableIndex),
|
||
Position = fromPosition + normalizedDirection * accumulatedDistance,
|
||
IsLogical = false,
|
||
LogicalNode = null,
|
||
SegmentIndex = segmentIndex,
|
||
StableIndex = stableIndex,
|
||
});
|
||
runtimeVirtualPointCount++;
|
||
}
|
||
}
|
||
|
||
private void SyncLogicalPointPositions()
|
||
{
|
||
for (var i = 0; i < chainPoints.Count; i++)
|
||
{
|
||
var point = chainPoints[i];
|
||
if (!point.IsLogical || point.LogicalNode == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
point.Position = point.LogicalNode.Position;
|
||
}
|
||
}
|
||
|
||
private static float[] BuildFirstSegmentGaps(float totalLength, float step)
|
||
{
|
||
if (totalLength <= 0f)
|
||
{
|
||
return new[] { 0f };
|
||
}
|
||
|
||
if (totalLength < step)
|
||
{
|
||
return new[] { totalLength };
|
||
}
|
||
|
||
var fullStepCount = Mathf.FloorToInt(totalLength / step);
|
||
var remainder = totalLength - (fullStepCount * step);
|
||
if (remainder > 0.0001f)
|
||
{
|
||
var gaps = new float[fullStepCount + 1];
|
||
gaps[0] = remainder;
|
||
for (var i = 1; i < gaps.Length; i++)
|
||
{
|
||
gaps[i] = step;
|
||
}
|
||
|
||
return gaps;
|
||
}
|
||
|
||
var divisibleGaps = new float[fullStepCount];
|
||
for (var i = 0; i < divisibleGaps.Length; i++)
|
||
{
|
||
divisibleGaps[i] = step;
|
||
}
|
||
|
||
return divisibleGaps;
|
||
}
|
||
|
||
|
||
private void UpdateJointLimit(int logicalNodeIndex, float limitValue)
|
||
{
|
||
if (logicalNodeIndex <= 0 || logicalNodeIndex >= logicalNodes.Length)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var node = logicalNodes[logicalNodeIndex];
|
||
if (node == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var joint = node.GetComponent<ConfigurableJoint>();
|
||
if (joint == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var limit = joint.linearLimit;
|
||
limit.limit = limitValue;
|
||
joint.linearLimit = limit;
|
||
}
|
||
|
||
private float GetSegmentLength(int segmentIndex)
|
||
{
|
||
if (segmentIndex <= 0)
|
||
{
|
||
return firstSegmentLength;
|
||
}
|
||
|
||
if (logicalNodes == null || segmentIndex >= logicalNodes.Length)
|
||
{
|
||
return 0f;
|
||
}
|
||
|
||
var sourceNode = logicalNodes[segmentIndex];
|
||
return sourceNode != null ? sourceNode.SegmentLengthToNext : 0f;
|
||
}
|
||
|
||
private FishingLineNode FindFirstValidLogicalNode()
|
||
{
|
||
if (logicalNodes == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
for (var i = 0; i < logicalNodes.Length; i++)
|
||
{
|
||
if (logicalNodes[i] != null)
|
||
{
|
||
return logicalNodes[i];
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private FishingLineNode FindLastValidLogicalNode()
|
||
{
|
||
if (logicalNodes == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
for (var i = logicalNodes.Length - 1; i >= 0; i--)
|
||
{
|
||
if (logicalNodes[i] != null)
|
||
{
|
||
return logicalNodes[i];
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private static long BuildLogicalPointKey(int logicalIndex)
|
||
{
|
||
return (1L << 62) | (uint)logicalIndex;
|
||
}
|
||
|
||
private static long BuildVirtualPointKey(int segmentIndex, int stableIndex)
|
||
{
|
||
return ((long)(segmentIndex + 1) << 32) | (uint)stableIndex;
|
||
}
|
||
}
|
||
} |