C# Path.Peek方法代码示例

        private void SetPath(Path path, bool isWaypoint)
        {
            _endOfResolvedPath = path.Last().position;
            _currentGrid = GridManager.instance.GetGrid(path.Peek().position);

            if (isWaypoint)
            {
                _remainingPathDistance += path.CalculateLength();

                _currentPath = _currentPath.AppendSegment(path);
            }
            else
            {
                if (!TrimPath(path))
                {
                    RequestPath(_transform.position, _wayPoints.desiredEndOfPath, InternalPathRequest.Type.Normal);
                    _currentPath = null;
                    return;
                }

                _currentPath = path;
                _remainingPathDistance = path.CalculateLength();

                //Pop the first node as our next destination.
                _currentDestination = path.Pop();
                _curPlannedDirection = _transform.position.DirToXZ(_currentDestination.position);
            }

            _unit.hasArrivedAtDestination = false;
        }

        private bool TrimPath(Path path)
        {
            //Make sure that the path was resolved before moving too far from where it was requested.
            var nn = _pathSettings.nextNodeDistance;
            if (_unit.position.DirToXZ(path.Peek().position).sqrMagnitude < nn * nn)
            {
                return true;
            }

            //First thing to do is to remove any waypoints that have already been reached.
            //Since the actual waypoints may differ from the requested ones (if they were corrected to allow the unit to access them)
            //we cannot remove them by comparison.
            //Since the last point is now always a waypoint (but not a via point), we skip that as obviously the last point cannot be pruned.
            int currentWaypointCount = _wayPoints.viaPointsCount;
            int pathCount = path.count;
            int encounteredWaypoints = 0;
            for (int i = pathCount - 2; i >= 0; i--)
            {
                var node = path[i];
                if (node is Waypoint)
                {
                    if (encounteredWaypoints == currentWaypointCount)
                    {
                        path.Truncate(i + 1);
                        break;
                    }

                    encounteredWaypoints++;
                }
            }

            //Next find the last node on the path to which we can move directly, i.e. skipping nodes already reached.
            var gridBounds = _currentGrid.bounds;
            var matrix = _currentGrid.cellMatrix;
            var costStrategy = GameServices.cellCostStrategy;

            int firstNodeIdx = -1;
            pathCount = path.count;
            for (int i = 0; i < pathCount; i++)
            {
                //If we haven't yet found an accessible node move on if the inspected node is outside the current grid or is a portal.
                //Otherwise stop, we do not move past portals.
                var node = path[i];
                if (node is IPortalNode || !gridBounds.Contains(node.position))
                {
                    if (firstNodeIdx < 0)
                    {
                        continue;
                    }

                    break;
                }

                if (PathSmoother.CanReducePath(node, _unit, _unit, matrix, costStrategy))
                {
                    firstNodeIdx = i;
                }
                else if (firstNodeIdx >= 0)
                {
                    break;
                }

                //We must visit waypoint so they cannot be smoothed away
                if (node is Waypoint)
                {
                    break;
                }
            }

            if (firstNodeIdx < 0)
            {
                return false;
            }

            path.Truncate(firstNodeIdx);
            return true;
        }