/// <summary> /// Attempts to find a <see cref="Path"/> between the start and end points and returns the result on completion. /// </summary> /// <param name="start">The <see cref="Index"/> into the search space representing the start position</param> /// <param name="end">The <see cref="Index"/> into the search space representing the end position</param> /// <param name="diagonal">The diagonal mode used when finding paths</param> /// <returns>The <see cref="Path"/> that was found or null if the algorithm failed</returns> public Path findPathImmediate(Index start, Index end, DiagonalMode diagonal) { PathRequestStatus status = PathRequestStatus.InvalidIndex; // Call through return(findPathImmediate(start, end, out status, diagonal)); }
// public void RequestPath(Node _StartNode, Node _TargetNode, MovementCommand _MovCom) { if (CurrentPathStatus == PathRequestStatus.NoneRequested) { CurrentPathStatus = PathRequestStatus.RequestedAndWaiting; PathFinderManager.Instance.RequestPathFromNodes(_StartNode, _TargetNode, _MovCom); } }
// public void RequestRandomPath() { if (CurrentPathStatus != PathRequestStatus.RequestedAndWaiting) { ResetPathing(); CurrentPathStatus = PathRequestStatus.RequestedAndWaiting; //PathFinderManager.Instance.RequestRandomPathFromVec3(transform.position, ThisGCM); } }
// public void RequestPath(Node _StartNode, Node _TargetNode, GunCrewMember _GCM, bool _SkipDiagnals) { if (CurrentPathStatus == PathRequestStatus.NoneRequested) { ResetPathing(); CurrentPathStatus = PathRequestStatus.RequestedAndWaiting; //PathFinderManager.Instance.RequestPathFromNodes(_StartNode, _TargetNode, _GCM); } }
public void SetPath(PotentialField completedPath, PathRequestStatus status) { switch (status) { case PathRequestStatus.Solved: var arrays = completedPath.PotentialArray.Arrays.Append(DynamicPotentialFieldComponent.PotentialField.Array); _path = new PotentialField(DynamicPotentialFieldComponent.PotentialField.GridTransformer, completedPath.TargetNode, arrays); break; case PathRequestStatus.NoPathFound: _path = new PotentialField(DynamicPotentialFieldComponent.PotentialField.GridTransformer, completedPath.TargetNode, DynamicPotentialFieldComponent.PotentialField.Array); break; } }
/// <summary> /// Called by AStar2D when the algorithm has completed the request. /// Note that the methods can private or public. /// </summary> /// <param name="path"></param> /// <param name="status"></param> private void onPathFound(Path path, PathRequestStatus status) { // Check if the path contains any nodes. Typically this will only be true if the path has not yet been initialized or if a pathfinding request failed. if (path.IsEmpty == true) { Debug.Log("The path is empty path"); } // Check if the path is reachable. A path is defined as reachable when the following conditions are true: // The path contains one or more nodes. // Every node within the path is walkable. if (path.IsReachable == true) { Debug.Log("The path is reachable"); } }
// public void RecivePathRequest(PathRequest _CPR) { if (_CPR.PathIsFound == false) { CurrentPathStatus = PathRequestStatus.NoneRequested; StartCoroutine(Wait(0.25f)); RequestPath(_CPR.StartingNode, _CPR.TargetNode, _CPR.Requestee); } else { WayPoints = _CPR.CompletedPath; CurrentWaypoint = WayPoints[0]; CurrentPathStatus = PathRequestStatus.RecivedAndValid; CurrentMovementStatus = MovementStatus.MovingToNextWapoint; } }
public void FindPath(Index start, Index end, DiagonalMode diagonal, BaseTraversal2D traversal2D, PathRequestDelegate callback) { if (!IsValid(start) || !IsValid(end)) { return; } searchGrid.maxPathLength = maxPathLength; bool useThreading = allowThreading; if (useThreading == true) { AsyncPathRequest request = new AsyncPathRequest(searchGrid, start, end, diagonal, traversal2D, (Path path, PathRequestStatus status) => { PathView.setRenderPath(this, path); callback(path, status); }); ThreadManager.Active.asyncRequest(request); } else { PathRequestStatus status; Path result = FindPathImmediate(start, end, out status, diagonal); PathView.setRenderPath(this, result); callback(result, status); } Path FindPathImmediate(Index subStart, Index subEnd, out PathRequestStatus subStatus, DiagonalMode subDiagonal) { searchGrid.maxPathLength = maxPathLength; Path path = null; PathRequestStatus temp = PathRequestStatus.InvalidIndex; searchGrid.FindPath(subStart, subEnd, subDiagonal, traversal2D, (Path result, PathRequestStatus resultStatus) => { temp = resultStatus; if (resultStatus == PathRequestStatus.PathFound) { path = result; PathView.setRenderPath(this, path); } }); subStatus = temp; return(path); } }
private void onPathFound(Path path, PathRequestStatus status) { if (status == PathRequestStatus.PathFound) { // Cache the path and change state this.path = path; this.target = path.getNextNode(); // Check if we are at the starting node - if so then skip if (currentIndex == target.Index) { this.target = path.getNextNode(); } changeState(AgentState.FollowingPath); } else if (status == PathRequestStatus.SameStartEnd) { // Make sure the agent moves to the current location (The agent may have already started moving away) Path temp = new Path(); temp.push(searchGrid[currentIndex.X, currentIndex.Y], currentIndex); // Cache the path and change state this.path = temp; this.target = temp.getNextNode(); changeState(AgentState.FollowingPath); } else if (status == PathRequestStatus.PathNotFound) { // Trigger the message onDestinationUnreachable(); // Go back to idle mode changeState(AgentState.Idle); } else { // Go back to idle mode changeState(AgentState.Idle); } }
private void onPathFound(Path path, PathRequestStatus status) { if (status == PathRequestStatus.PathFound) { // Create the path session this.session = new PathSession(path); // Check if we are at the starting node - if so then skip if (currentIndex == session.Index) { // Skip the starting node session.advancePath(); } changeState(AgentState.FollowingPath); } else if (status == PathRequestStatus.SameStartEnd) { // Make sure the agent moves to the current location (The agent may have already started moving away) Path temp = new Path(null); temp.push(searchGrid[currentIndex.X, currentIndex.Y], currentIndex); // Change state changeState(AgentState.FollowingPath); } else if (status == PathRequestStatus.PathNotFound) { // Trigger the message onDestinationUnreachable(); // Go back to idle mode changeState(AgentState.Idle); } else { // Go back to idle mode changeState(AgentState.Idle); } }
private void OnPathFound(Path path, PathRequestStatus status) { if (status == PathRequestStatus.PathFound) { this.Session = new PathSession(path); OnMoveStart(); DoAdvanceNode(); ChangeState(AgentState.FollowingPath); } else if (status == PathRequestStatus.SameStartEnd) { ChangeState(AgentState.Idle); OnSameStartEnd(); } else if (status == PathRequestStatus.PathNotFound) { OnMoveUnreachable(); ChangeState(AgentState.Idle); } else { ChangeState(AgentState.Idle); } }
/// <summary> /// Attempts to find a <see cref="Path"/> between the start and end points and returns the result on completion. /// </summary> /// <param name="start">The <see cref="Index"/> into the search space representing the start position</param> /// <param name="end">The <see cref="Index"/> into the search space representing the end position</param> /// <param name="status">The <see cref="PathRequestStatus"/> describing the state of the result</param> /// <param name="diagonal">The diagonal mode used when finding a path</param> /// <returns>The <see cref="Path"/> that was found or null if the algorithm failed</returns> public Path findPathImmediate(Index start, Index end, out PathRequestStatus status, DiagonalMode diagonal) { // Make sure the grid is ready if (verifyReady() == false) { status = PathRequestStatus.GridNotReady; return(null); } // Update max path length searchGrid.maxPathLength = maxPathLength; // Store a temp path Path path = null; PathRequestStatus temp = PathRequestStatus.InvalidIndex; // Find a path searchGrid.findPath(start, end, diagonal, (Path result, PathRequestStatus resultStatus) => { // Store the status temp = resultStatus; // Make sure the path was found if (resultStatus == PathRequestStatus.PathFound) { path = result; #if UNITY_EDITOR PathView.setRenderPath(this, path); #endif } }); status = temp; return(path); }
/// <summary> /// Attempts to find a <see cref="Path"/> between the start and end points and returns the result on completion. /// </summary> /// <param name="start">The <see cref="Index"/> into the search space representing the start position</param> /// <param name="end">The <see cref="Index"/> into the search space representing the end position</param> /// <param name="status">The <see cref="PathRequestStatus"/> describing the state of the result</param> /// <param name="diagonal">The diagonal mode used when finding paths</param> /// <returns>The <see cref="Path"/> that was found or null if the algorithm failed</returns> public abstract Path findPathImmediate(Index start, Index end, out PathRequestStatus status, DiagonalMode diagonal);
// Constructor /// <summary> /// Parameter constructor. /// </summary> /// <param name="path">The resulting path</param> /// <param name="status">The status of the request</param> public MonoDelegateEvent(Path path, PathRequestStatus status) { this.path = path; this.status = status; }
// public void RecivePathRequest(List <Node> _NodePath) { WayPoints = _NodePath; CurrentPathStatus = PathRequestStatus.Recived; //Debug.Log(gameObject.name + " Recived a Path! It is " + WayPoints.Count + " Nodes Long"); }
public void MoveAlongPath() { if (WayPoints == null) { return; } CurrentPathStatus = PathRequestStatus.NoneRequested; //if (CurrentMovementStatus == MovementStatus.Idle && CurrentWaypoint != null) // CurrentMovementStatus = MovementStatus.MovingToNextWapoint; switch (CurrentMovementStatus) { case MovementStatus.Null: ThisRB.velocity = Vector3.zero; break; case MovementStatus.Idle: ThisRB.velocity = Vector3.zero; break; case MovementStatus.MovingToNextWapoint: CheckForWayPointExistance(); float CurrentDisFromWaypoint = Vector3.Distance(transform.position, CurrentWaypoint.WorldPosition); if (CurrentDisFromWaypoint < 0.3f) { if (CurrentWaypoint == TargetWaypoint) { CurrentMovementStatus = MovementStatus.ArrivedAtTargetNode; ThisGCM.OccupiedNode = CurrentWaypoint; return; } ++CurrentWaypointIndex; if (WayPoints[CurrentWaypointIndex] != null) { CurrentWaypoint = WayPoints[CurrentWaypointIndex]; ThisGCM.OccupiedNode = CurrentWaypoint; CurrentMovementStatus = MovementStatus.MovingToNextWapoint; } } else { //THIS LOOK AT SHOULD BE 50% of the Collider height for the Y Vector3 LookAtTarget = new Vector3(CurrentWaypoint.WorldPosition.x, 0.25f, CurrentWaypoint.WorldPosition.z); float step = RotationSpeed * Time.deltaTime; Vector3 targetDir = LookAtTarget - transform.position; RotationToNextWaypoint = targetDir; Vector3 newDir = Vector3.RotateTowards(transform.forward, targetDir, step, 0.0f); transform.rotation = Quaternion.LookRotation(newDir); ThisRB.velocity = transform.forward * Speed; } break; case MovementStatus.ArrivedAtWaypoint: break; case MovementStatus.ArrivedAtTargetNode: ThisRB.velocity = Vector3.zero; transform.rotation = Quaternion.Euler(transform.forward); WayPoints = null; CurrentWaypointIndex = 0; ThisGCM.OccupiedNode = CurrentWaypoint; //RequestRandomPath(); CurrentMovementStatus = MovementStatus.Idle; break; } }
// Constructor public AsyncPathResult(AsyncPathRequest request, Path result, PathRequestStatus status) { this.request = request; this.result = result; this.status = status; }