/* Call to update the bestPath with the closest path one of the targets.
* It will take a few frames for this to be calculated, the bestPath variable will be null in the meantime
*/
public void SearchClosest()
{
//If any paths are currently being calculated, cancel them to avoid wasting processing power
if (lastPaths != null)
{
for (int i = 0; i < lastPaths.Length; i++)
{
lastPaths[i].Error();
}
}
//Create a new lastPaths array if necessary (can reuse the old one?)
if (lastPaths == null || lastPaths.Length != targets.Length)
{
lastPaths = new Path[targets.Length];
}
//Reset variables
bestPath = null;
numCompleted = 0;
//Loop through the targets
for (int i = 0; i < targets.Length; i++)
{
//Create a new path to the target
ABPath p = ABPath.Construct(transform.position, targets[i].position, OnTestPathComplete);
/* Before version 3.2
* Path p = new Path (transform.position,targets[i].position, OnTestPathComplete);
*/
lastPaths[i] = p;
//Request the path to be calculated, might take a few frames
//This will call OnTestPathComplete when completed
AstarPath.StartPath(p);
}
}
// Update is called once per frame
protected void Update()
{
//base.Update();
path = ABPath.Construct(this.transform.position, this.GetComponent <EnemyAI>().target.position, null);
path.traversalProvider = traversalProvider;
AstarPath.StartPath(path);
path.BlockUntilCalculated();
path.Claim(this);
if (path.error == true)
{
Debug.Log("No Path Was Found.");
}
else
{
Debug.Log("A Path Was Found With: " + path.vectorPath.Count + " Nodes");
for (int i = 0; i < path.vectorPath.Count - 1; i++)
{
Debug.DrawLine(path.vectorPath[i], path.vectorPath[i + 1], Color.red);
}
this.GetComponent <Seeker>().StartPath(path.startPoint, path.endPoint, OnPathCompleteCallback);
}
}
public virtual void Repath()
{
// Check that there is a target somewhere and if not, try to find one
if (target == null)
{
target = FindNearestHostile(tagOfHostiles);
}
// There is no target for now
if (target == null)
{
animation.Play("idle");
}
// Nothing to do, just wait
if (seeker == null || target == null || !seeker.IsDone())
{
return;
}
// Calculate a path from my current location to the target's location
Path path = ABPath.Construct(transform.position, target.transform.position, null);
// Start pathfinding
seeker.StartPath(path, OnPathComplete);
}
/** Recalculates the path to #target.
* Queries a path request to the Seeker, the path will not be calculated instantly, but will be put on a queue and calculated as fast as possible.
* It will wait if the current path request by this seeker has not been completed yet.
* \see Seeker.IsDone */
public virtual void Repath()
{
lastPathSearch = Time.time;
if (seeker == null || target == null || !canSearch || !seeker.IsDone())
{
StartCoroutine(WaitToRepath());
return;
}
//for (int i=0;i<1000;i++) {
//MultithreadPath mp = new MultithreadPath (transform.position,target.position,null);
//Path p = new Path (transform.position,target.position,null);
// AstarPath.StartPath (mp);
//}
//Debug.Log (AstarPath.pathQueue.Count);
//StartCoroutine (WaitToRepath ());
/*ConstantPath cpath = new ConstantPath(transform.position,null);
* //Must be set to avoid it from searching towards Vector3.zero
* cpath.heuristic = Heuristic.None;
* //Here you set how far it should search
* cpath.maxGScore = 2000;
* AstarPath.StartPath (cpath);*/
//FloodPathTracer fpathTrace = new FloodPathTracer (transform.position,fpath,null);
//seeker.StartPath (fpathTrace,OnPathComplete);
Path p = ABPath.Construct(transform.position, target.position, null);
seeker.StartPath(p, OnPathComplete);
//Start a new path from transform.positon to target.position, return the result to the function OnPathComplete
//seeker.StartPath (transform.position,target.position,OnPathComplete);
}
public IEnumerator GetPathCost(Unit unit, Vector3Int targetPosition)
{
selected = unit;
GeneratePossibleMoves();
Vector3 start = GridManager.GetTileToCellFromWorld(unit.positionGrid);
Vector3 end = GridManager.GetTileToCellFromWorld(targetPosition);
ABPath path = ABPath.Construct(unit.transform.position, end);
path.traversalProvider = unit.traversalProvider;
AstarPath.StartPath(path);
while (path.vectorPath.Count == 0)
{
StartCoroutine(path.WaitForPath());
}
//yield return StartCoroutine(path.WaitForPath());
if (path.error)
{
Debug.LogError("Path failed:\n" + path.errorLog);
GeneratePossibleMoves();
yield break;
}
movementCost = path.vectorPath.Count - 1;
//Debug.Log(unit.gameObject.name + " postion: " + unit.positionGrid + " target postion: " + targetPosition + " cost: " + (path.vectorPath.Count - 1));
DestroyPossibleMoves();
}
public void AttemptMove()
{
if (turnSpeed != turnSpeedCounter)
{
turnSpeedCounter++;
return;
}
turnSpeedCounter = 1;
CalculateObstacles();
path = ABPath.Construct(movingToPoint.position, target.position, null);
path.traversalProvider = traversalProvider;
AstarPath.StartPath(path);
path.BlockUntilCalculated();
if (!path.error)
{
if (path.vectorPath.Count > 2)
{
movingToPoint.position = path.vectorPath[1];
blocker.BlockAt(path.vectorPath[1]);
path.vectorPath.RemoveAt(0);
}
else if (path.vectorPath.Count <= 2 && target == FindObjectOfType <PlayerMovePoint>().transform)
{
//ATTACK PLAYER
Health playerHealth = FindObjectOfType <PlayerMovement>().GetComponent <Health>();
playerHealth.DecreaseHealth(GetComponent <DamageDealer>().GetDamage());
}
}
}
IEnumerator MoveToNode(TurnBasedAI unit, GraphNode node)
{
var path = ABPath.Construct(unit.transform.position, (Vector3)node.position);
path.traversalProvider = unit.traversalProvider;
// Schedule the path for calculation
AstarPath.StartPath(path);
// Wait for the path calculation to complete
yield return(StartCoroutine(path.WaitForPath()));
if (path.error)
{
// Not obvious what to do here, but show the possible moves again
// and let the player choose another target node
// Likely a node was blocked between the possible moves being
// generated and the player choosing which node to move to
Debug.LogError("Path failed:\n" + path.errorLog);
state = State.SelectTarget;
GeneratePossibleMoves(selected);
yield break;
}
// Set the target node so other scripts know which
// node is the end point in the path
unit.targetNode = path.path[path.path.Count - 1];
yield return(StartCoroutine(MoveAlongPath(unit, path, movementSpeed)));
unit.blocker.BlockAtCurrentPosition();
// Select a new unit to move
state = State.SelectUnit;
}
public void MoveToPosWithPath_Impl(MoveWithPath item)
{
if (GlobalSettings.Instance.PvpSetting.isPlayerMoveBeforeServer && Singleton <PvpManager> .Instance.IsInPvp && this.self.isPlayer)
{
return;
}
if (item == null)
{
return;
}
this.moveWithPath = item;
this.self.serverTargetPos = MoveController.ServerPosInvalide;
if (this.self.isMonster)
{
this.self.serverTargetPos = MoveController.SVectgor3ToVector3(item.toPos);
this.path = ABPath.Construct(this.self.transform.position, MoveController.SVectgor3ToVector3(item.toPos), null);
this.path.vectorPath = new List <Vector3>();
foreach (SVector3 current in item.path)
{
this.path.vectorPath.Add(MoveController.SVectgor3ToVector3(current));
}
this.navAgent.MoveWithPath(item.targetUnitId, MoveController.SVectgor3ToVector3(item.toPos), item.stopDistance, this.path);
if (item.tick > this.lastServerTick)
{
this.lastServerTick = item.tick;
this.lastServerPos = MoveController.SVectgor3ToVector3(item.pos);
}
}
}
void UpdatePath()
{
//如果当前正在计算任何路径，则取消它们以避免浪费处理能力
if (lastPaths != null)
{
for (int i = 0; i < lastPaths.Length; i++)
{
lastPaths[i].Error();
}
}
//如果需要，创建一个新的lastPaths数组
if (lastPaths == null || lastPaths.Length != targets.Length)
{
lastPaths = new Path[targets.Length];
}
bestPath = null;
numCompleted = 0;
//遍历目标点并生成到其路径数组
for (int i = 0; i < targets.Length; i++)
{
//创建一条新的路径到当前目标点
ABPath p = ABPath.Construct(transform.position, targets[i].position, OnTestPathComplete);
lastPaths[i] = p;
//请求要计算的路径，可能需要几帧
//这将在完成时调用OnTestPathComplete
AstarPath.StartPath(p);
}
//if (seeker.IsDone())
// seeker.StartPath(rb.position, Target.position,OnPathComplete);
}
/// <summary>
/// 判断路径是否有效
/// </summary>
/// <param name="startPosition"></param>
/// <param name="endPosition"></param>
/// <returns></returns>
public IEnumerator CheckPath(Vector3 startPosition, Vector3 endPosition)
{
ABPath path = ABPath.Construct(startPosition, endPosition);
AstarPath.StartPath(path);
yield return(StartCoroutine(path.WaitForPath()));
}
/// <summary>
/// 初始化AI数据
/// </summary>
/// <param name="player"></param>
public void OnInit(Monster monster)
{
m_Monster = monster;
Path p = ABPath.Construct(m_Monster.m_Pos.ToVector3(), m_Monster.m_MonsterData.m_NaviPos.ToVector3(), OnPathComplete);
AstarPath.StartPath(p);
}
/** Returns a new path instance.
* The path will be taken from the path pool if path recycling is turned on.\n
* This path can be sent to #StartPath(Path,OnPathDelegate,int) with no change, but if no change is required #StartPath(Vector3,Vector3,OnPathDelegate) does just that.
* \code var seeker = GetComponent<Seeker>();
* Path p = seeker.GetNewPath (transform.position, transform.position+transform.forward*100);
* // Disable heuristics on just this path for example
* p.heuristic = Heuristic.None;
* seeker.StartPath (p, OnPathComplete);
* \endcode
*/
public ABPath GetNewPath(Vector3 start, Vector3 end)
{
// Construct a path with start and end points
ABPath p = ABPath.Construct(start, end, null);
return(p);
}
private void OnPathCalculationDone(Path path)
{
if (path.PipelineState == PathState.Returned)
{
AILerp.SetPath(path);
}
else if (path.CompleteState == PathCompleteState.Error)
{
if (randomStart < startingPoints.Length)
{
randomStart++;
}
else if (randomStart > 0)
{
randomStart--;
}
if (randomEnd < endingPoints.Length)
{
randomEnd++;
}
else if (randomStart > 0)
{
randomEnd--;
}
Path nextPath = ABPath.Construct(startingPoints[randomStart].Vector3FromCoordinates, endingPoints[randomEnd].Vector3FromCoordinates, OnPathCalculationDone);
AILerp.SetPath(path);
}
}
public void Update()
{
// Create a new Path object
var path = ABPath.Construct(transform.position, target.position, null);
// Make the path use a specific traversal provider
path.traversalProvider = traversalProvider;
// Calculate the path synchronously
AstarPath.StartPath(path);
path.BlockUntilCalculated();
if (path.error)
{
Debug.Log("No path was found");
}
else
{
Debug.Log("A path was found with " + path.vectorPath.Count + " nodes");
// Draw the path in the scene view
for (int i = 0; i < path.vectorPath.Count - 1; i++)
{
Debug.DrawLine(path.vectorPath[i], path.vectorPath[i + 1], Color.red);
}
}
}
private void CalculateAllPathsInfo(List <Building> bds)
{
//If any paths are currently being calculated, cancel them to avoid wasting processing power
if (mLastPaths != null)
{
//mLastPaths = null;
for (int i = 0; i < mLastPaths.Length; i++)
{
mLastPaths [i].Error();
}
}
//Create a new lastPaths array if necessary (can reuse the old one?)
int validbuildingnumbers = 0; //= MapManager.mMapInstance.NullWallBuildingNumber;
int nullwallbuildingnumbers = bds.Count;
foreach (Building nwbd in bds)
{
if (nwbd.mBI.IsDestroyed != true)
{
validbuildingnumbers++;
}
}
if (mLastPaths == null || mLastPaths.Length != validbuildingnumbers)
{
mLastPaths = new Path[validbuildingnumbers];
}
Building bd = null;
int pathindex = 0;
for (int i = 0; i < nullwallbuildingnumbers; i++)
{
//foreach (Building bd in MapManager.mMapInstance.BuildingsInfoInGame) {
//bd = MapManager.mMapInstance.BuildingsInfoInGame[i];
/*
* if( bd.mBI.IsDestroyed || bd.mBI.mBT == BuildingType.E_WALL)
* {
* //Debug.Log("IsDestroyed = " + bd.mBI.IsDestroyed);
* continue;
* }
* else
* {
*/
Debug.Log("CalculateAllPathsInfo() called");
bd = bds[i];
if (bd.mBI.IsDestroyed != true)
{
Debug.Log("transform.position = " + transform.position);
Debug.Log("bd.transform.position = " + bd.transform.position);
ABPath p = ABPath.Construct(transform.position, bd.transform.position, OnPathInfoComplete);
mLastPaths[pathindex] = p;
AstarPath.StartPath(p);
pathindex++;
}
//}
}
}
public void CalculatePath()
{
var pos = (target == null) ? targetPosition : (target.transform.position + targetPosition);
p = ABPath.Construct(go.transform.position, pos, OnPathComplete); // create path from current position to closest/first node
AstarPath.StartPath(p); //make the actual vector3 path which we'll use lateron.
pUpdate = 0;
}
/** Starts a path specified by PathTypesDemo.activeDemo */
public void DemoPath()
{
Path p = null;
if (activeDemo == 0)
{
p = ABPath.Construct(start.position, end.position, OnPathComplete);
}
else if (activeDemo == 1)
{
MultiTargetPath mp = MultiTargetPath.Construct(multipoints.ToArray(), end.position, null, OnPathComplete);
p = mp;
}
else if (activeDemo == 2)
{
RandomPath rp = RandomPath.Construct(start.position, searchLength, OnPathComplete);
rp.spread = spread;
rp.aimStrength = aimStrength;
rp.aim = end.position;
rp.replaceChance = replaceChance;
p = rp;
}
else if (activeDemo == 3)
{
FleePath fp = FleePath.Construct(start.position, end.position, searchLength, OnPathComplete);
fp.aimStrength = aimStrength;
fp.replaceChance = replaceChance;
fp.spread = spread;
p = fp;
}
else if (activeDemo == 4)
{
ConstantPath constPath = ConstantPath.Construct(end.position, searchLength, OnPathComplete);
p = constPath;
}
else if (activeDemo == 5)
{
FloodPath fp = FloodPath.Construct(end.position, null);
lastFlood = fp;
p = fp;
}
else if (activeDemo == 6 && lastFlood != null)
{
FloodPathTracer fp = FloodPathTracer.Construct(end.position, lastFlood, OnPathComplete);
p = fp;
}
if (p != null)
{
AstarPath.StartPath(p);
lastPath = p;
}
}
private void RandomlyChoosePath(Tile[] startingPoints, Tile[] endingPoints)
{
randomStart = UnityEngine.Random.Range(0, startingPoints.Length);
randomEnd = UnityEngine.Random.Range(0, endingPoints.Length);
this.startingPoints = startingPoints;
this.endingPoints = endingPoints;
Path path = ABPath.Construct(startingPoints[randomStart].Vector3FromCoordinates, endingPoints[randomEnd].Vector3FromCoordinates, OnPathCalculationDone);
AILerp.SetPath(path);
}
public virtual void Repath()
{
this.lastPathSearch = Time.time;
if (this.seeker == null || this.target == null || !this.canSearch || !this.seeker.IsDone())
{
base.StartCoroutine(this.WaitToRepath());
return;
}
Path p = ABPath.Construct(base.transform.position, this.target.position, null);
this.seeker.StartPath(p, new OnPathDelegate(this.OnPathComplete), -1);
}
private void SearchPath()
{
_pathTimer.Activate();
_waitingForPathCalculation = true;
_seeker.CancelCurrentPathRequest();
var p = ABPath.Construct(Tr.position, MoveTarget);
p.traversalProvider = _traversal;
_seeker.StartPath(p);
//_seeker.StartPath(Tr.position, MoveTarget);
}
// Token: 0x060029EC RID: 10732 RVA: 0x001C21BC File Offset: 0x001C03BC
private void DemoPath()
{
Path path = null;
switch (this.activeDemo)
{
case PathTypesDemo.DemoMode.ABPath:
path = ABPath.Construct(this.start.position, this.end.position, new OnPathDelegate(this.OnPathComplete));
break;
case PathTypesDemo.DemoMode.MultiTargetPath:
base.StartCoroutine(this.DemoMultiTargetPath());
break;
case PathTypesDemo.DemoMode.RandomPath:
{
RandomPath randomPath = RandomPath.Construct(this.start.position, this.searchLength, new OnPathDelegate(this.OnPathComplete));
randomPath.spread = this.spread;
randomPath.aimStrength = this.aimStrength;
randomPath.aim = this.end.position;
path = randomPath;
break;
}
case PathTypesDemo.DemoMode.FleePath:
{
FleePath fleePath = FleePath.Construct(this.start.position, this.end.position, this.searchLength, new OnPathDelegate(this.OnPathComplete));
fleePath.aimStrength = this.aimStrength;
fleePath.spread = this.spread;
path = fleePath;
break;
}
case PathTypesDemo.DemoMode.ConstantPath:
base.StartCoroutine(this.DemoConstantPath());
break;
case PathTypesDemo.DemoMode.FloodPath:
path = (this.lastFloodPath = FloodPath.Construct(this.end.position, null));
break;
case PathTypesDemo.DemoMode.FloodPathTracer:
if (this.lastFloodPath != null)
{
path = FloodPathTracer.Construct(this.end.position, this.lastFloodPath, new OnPathDelegate(this.OnPathComplete));
}
break;
}
if (path != null)
{
AstarPath.StartPath(path, false);
this.lastPath = path;
}
}
public void CalculatePath()
{
if (moveMode != MoveMode.follow && moveMode != MoveMode.followTo && moveMode != MoveMode.fleeContinuously)
{
path = null;
} // do this to avoid instant finishing if the action had been called before and if the actor didn't move
Vector3 targetPos;
if (target.Value != null)
{
targetPos = target.Value.transform.position + targetPosition.Value;
}
else
{
targetPos = targetPosition.Value;
}
if (path != null && path.vectorPath.Count > 0 && (moveMode == MoveMode.follow || moveMode == MoveMode.followTo))
{
p = ABPath.Construct(nextPos, targetPos, OnPathComplete);
} // create path from next waypoint (to avoid jitter due to sudden direction change on path update) to closest/first node
else if (moveMode != MoveMode.fleeContinuously && moveMode != MoveMode.flee && moveMode != MoveMode.randomPath)
{
p = ABPath.Construct(go.transform.position, targetPos, OnPathComplete);
} // create path from current position to closest/first node
else if (moveMode == MoveMode.fleeContinuously || moveMode == MoveMode.flee)
{
if (AstarPath.HasPro)
{
p = FleePath.Construct(go.transform.position, targetPos, (int)(length.Value * 1000f), OnPathComplete);
} // create path from current position to closest/first node
else
{
p = ABPath.Construct(go.transform.position, go.transform.position + (go.transform.position - targetPos).normalized * length.Value, OnPathComplete);
}
}
else if (moveMode == MoveMode.randomPath)
{
if (AstarPath.HasPro)
{
p = RandomPath.Construct(go.transform.position, (int)(length.Value * 1000f), OnPathComplete);
} // create path from current position to closest/first node
else // random direction! This is just a cheap immitation of the real randompath!
{
p = ABPath.Construct(go.transform.position, go.transform.position + new Vector3(UnityEngine.Random.Range(-1f, 1f), 0f, UnityEngine.Random.Range(-1f, 1f)).normalized *length.Value, OnPathComplete);
}
}
AstarPath.StartPath(p); //make the actual vector3 path which we'll use lateron.
time = Time.time;
return;
}
/// <summary>Starts a path specified by PathTypesDemo.activeDemo</summary>
void DemoPath()
{
Path p = null;
switch (activeDemo)
{
case DemoMode.ABPath:
p = ABPath.Construct(start.position, end.position, OnPathComplete);
break;
case DemoMode.MultiTargetPath:
StartCoroutine(DemoMultiTargetPath());
break;
case DemoMode.ConstantPath:
StartCoroutine(DemoConstantPath());
break;
case DemoMode.RandomPath:
RandomPath rp = RandomPath.Construct(start.position, searchLength, OnPathComplete);
rp.spread = spread;
rp.aimStrength = aimStrength;
rp.aim = end.position;
p = rp;
break;
case DemoMode.FleePath:
FleePath fp = FleePath.Construct(start.position, end.position, searchLength, OnPathComplete);
fp.aimStrength = aimStrength;
fp.spread = spread;
p = fp;
break;
case DemoMode.FloodPath:
p = lastFloodPath = FloodPath.Construct(end.position, null);
break;
case DemoMode.FloodPathTracer:
if (lastFloodPath != null)
{
FloodPathTracer fpt = FloodPathTracer.Construct(end.position, lastFloodPath, OnPathComplete);
p = fpt;
}
break;
}
if (p != null)
{
AstarPath.StartPath(p);
lastPath = p;
}
}
public void ShowPath()
{
Path p = null;
p = ABPath.Construct(start.position, end.position, OnPathComplete);
if (p != null)
{
AstarPath.StartPath(p);
lastPath = p;
}
}
/// <summary>
/// This method calculate the path that will be taken by the unit and also shows the path nodes that will be used.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private IEnumerator HandlePathSelection(GraphNode node, System.Action actionCompleted = null)
{
moveCompleted = false;
ABPath path = ABPath.Construct(selected.transform.position, (Vector3)node.position);
path.traversalProvider = selected.traversalProvider;
AstarPath.StartPath(path);
while (path.vectorPath.Count == 0)
{
StartCoroutine(path.WaitForPath());
}
if (path.error)
{
Debug.LogError("Path failed:\n" + path.errorLog);
GeneratePossibleMoves();
yield break;
}
for (int i = 0; i < path.vectorPath.Count; i++)
{
AddCurrentPathToOverlay(path.vectorPath[i]);
}
movementCost = GridManager.PathNodesOverlayTiles.Count - 1;
GridManager.DrawCurrentPathNodes();
/// check for the input behaviours when the AI is playing
if ((InputManager.Instance.canUseInputs && Input.GetMouseButtonDown(0)) ^ (selected is AIEnemy))
{
/// Disable Inputs for player
DisableInputs(selected, false);
/// Select target node for AStar
selected.targetNode = path.path[path.path.Count - 1];
/// Clear Overlay Tiles
GridManager.ClearTiles();
/// Destroy Previous Tiles Overlay
DestroyPossibleMoves();
/// Move along path AStar
yield return(StartCoroutine(MoveAlongPath(selected, path, movementSpeed)));
/// Enable Inputs
DisableInputs(selected, true);
/// Deselect AStar Unit
Deselect();
/// Confirm that the move is complete
moveCompleted = true;
actionCompleted?.Invoke();
}
}
public void CalculatePath()
{
path = ABPath.Construct(go.transform.position, targetPosition.Value, OnPathComplete); // create path from current position to closest/first node
AstarPath.StartPath(path); //make the actual vector3 path which we'll use lateron.
if (LogEvents.Value)
{
Debug.Log("Start Position" + go.transform.position + "End Position" + targetPosition.Value);
}
return;
}
public virtual void Repath()
{
lastPathSearch = Time.time;
if (seeker == null || target == null || !canSearch || !seeker.IsDone())
{
StartCoroutine(WaitToRepath());
return;
}
Path p = ABPath.Construct(transform.position, target.position, null);
seeker.StartPath(p, OnPathComplete);
}
private Path GetPath(HexTile startingCell, HexTile targetCell, OnPathDelegate onComplete)
{
if (AstarPath.active == null)
{
Debug.LogError("Astar not active", this);
return(null);
}
var p = ABPath.Construct(startingCell.transform.position, targetCell.transform.position, onComplete);
AstarPath.StartPath(p);
return(p);
}
//计算AB路径
public ABPath StartABPath(Vector3 start, Vector3 end, ITraversalProvider traversalProvider, OnPathDelegate callback)
{
var path = ABPath.Construct(start, end, callback);
path.traversalProvider = traversalProvider;
if (callback != null)
{
}
else
{
path.BlockUntilCalculated();
}
AstarPath.StartPath(path);
return(path);
}
/// <summary>
/// 判断路径是否有效
/// </summary>
/// <param name="startPosition"></param>
/// <param name="endPosition"></param>
/// <returns></returns>
public static bool CheckPath(Vector3 startPosition, Vector3 endPosition)
{
ABPath path = ABPath.Construct(startPosition, endPosition);
path.calculatePartial = true;
AstarPath.StartPath(path);
AstarPath.BlockUntilCalculated(path);
if (path.originalEndPoint == path.endPoint)
{
return(true);
}
else
{
return(false);
}
}
