/// <inheritdoc/>
public PathfindingResponse FindJumpPointsWithSpatialAstar(Position startPoint, Position targetPoint)
{
if (!_ready)
{
InitializeAlgorithms(_contextManager.Current);
}
Point startPointPoint = _contextManager.Current.PathfindingData.PositionToZeroBasedPoint(startPoint);
Point targetPointPoint = _contextManager.Current.PathfindingData.PositionToZeroBasedPoint(targetPoint);
int nodesOpen, nodesClosed;
LinkedList <MyPathNode> path = _spatialAStar.Search(startPointPoint, targetPointPoint, Position.Zero, out nodesOpen, out nodesClosed);
//Debug.Log($"{(path==null?"Failed " : "")} Path from {startPoint} to {targetPoint} with {path?.Count} steps, {nodesOpen} open nodes, {nodesClosed} closed nodes.");
if (path == null || !path.Any())
{
return(new PathfindingResponse(PathfindingResult.FailureTargetUnreachable));
}
List <Position> resultJumpPointsInGrid = path.Select(p => p.Position).ToList();
List <Position> naturalJumpPoints = _naturalLineCalculator.GetNaturalJumpPoints(resultJumpPointsInGrid).ToList();
return(new PathfindingResponse(naturalJumpPoints));
}
public IEnumerable <WalkableNode> GetPath(Vector3 destination)
{
if (m_Solver == null)
{
CreateSolver();
}
return(m_Solver.Search(
(Vector2)m_CurrentCell,
(Vector2)m_DestinationCell,
null));
}
public static MovementPath AStar(Point start, Point end, Stage stage = null)
{
MovementPath newPath = new MovementPath(null);
if (stage == null)
{
stage = Stage.CurrentStage;
}
// setup grid with walls
//MyPathNode[,] grid = new MyPathNode[(int)stage.Width, (int)stage.Height];
MyPathNode[][] grid = new MyPathNode[(int)stage.Width][];
for (int x = 0; x < (int)stage.Width; x++)
{
grid[x] = new MyPathNode[(int) stage.Height];
for (int y = 0; y < (int)stage.Height; y++)
{
grid[x][y] = new MyPathNode()
{
IsWall = stage.GetTileAt(x, y).GetWalkable(),
X = x,
Y = y,
};
}
}
SpatialAStar<MyPathNode, Object> aStar = new SpatialAStar<MyPathNode, Object>(grid);
LinkedList<MyPathNode> path = aStar.Search(new Point(0, 0),
new Point(stage.Width - 2, stage.Height - 2), null);
return null;
}
void Awake()
{
// setup grid with walls
MyPathNode[,] grid = new MyPathNode[Width, Height];
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
bool isWall = ((y % 2) != 0) && (Random.Range(0, 10) != 8);
grid[x, y] = new MyPathNode()
{
IsWall = isWall,
X = x,
Y = y,
};
}
}
// second generic parameter should be the argument type for IsWalkable (I'm using GameObject)
SpatialAStar <MyPathNode, Object> aStar = new SpatialAStar <MyPathNode, Object>(grid);
// start point, desired end point,
// the third parameter is the value passed to IsWalkable (eg, the GameObject of the NPC doing the walking)
// if not path is found, null is returned
LinkedList <MyPathNode> path = aStar.Search(new Point(0, 0),
new Point(Width - 2, Height - 2), null);
}
public void CalculatePath()
{
Vector2Int pos = new Vector2Int(Mathf.FloorToInt(transform.position.x), Mathf.FloorToInt(transform.position.y));
Vector2Int target = new Vector2Int(Mathf.FloorToInt(destination.x), Mathf.FloorToInt(destination.y));
path = aStar.Search(pos.x, pos.y, target.x, target.y, null);
}
private LinkedList <Cell> TestIfMapIsSolveable()
{
SpatialAStar <Cell, Object> aStar = new SpatialAStar <Cell, Object>(grid.Cells);
LinkedList <Cell> path = aStar.Search(new Point((int)player.Position.X / 20, (int)player.Position.Y / 20),
new Point((int)Goal.Position.X / 20, (int)Goal.Position.Y / 20), null);
return(path);
}
public LinkedList <ITile> Find(IBuilding building, IPoint placingPointOnMap)
{
_buildingOnMapLocator.BlockBuildingArea(_map, building, placingPointOnMap);
var closestStreet = _closestStreetFinder.Find(_map, placingPointOnMap);
var pathToNearestStreet = _astar.Search(
new AStarAlgorithm.Point(placingPointOnMap.X, placingPointOnMap.Y),
new AStarAlgorithm.Point(closestStreet.X, closestStreet.Y),
NeighbourClassification.ByWall);
_map.UnblockAllTemporarilyBlockedTiles();
return(pathToNearestStreet);
}
public IEnumerable<ILocation> GetWalkPoints (ILocation from, ILocation to)
{
if (_pathMask == null) yield break;
int fromX = (int)from.X;
int fromY = (int)from.Y;
int toX = (int)to.X;
int toY = (int)to.Y;
SpatialAStar<PathNode, object> finder = new SpatialAStar<PathNode, object> (_pathMask);
var paths = finder.Search (new Point (fromX, fromY),
new Point ((int)to.X, (int)to.Y), null);
if (paths == null)
yield break;
if (!SmoothPath)
{
foreach (var node in paths)
{
yield return new AGSLocation (node.X, node.Y, to.Z);
}
}
int currentDirX = paths.First.Value.X - fromX;
int currentDirY = paths.First.Value.Y - fromY;
PathNode prevNode = null;
PathNode prevAcceptedNode = paths.First.Value;
foreach (var node in paths)
{
if (prevNode != null)
{
int dirX = node.X - prevNode.X;
int dirY = node.Y - prevNode.Y;
if (dirX != currentDirX || dirY != currentDirY)
{
if (Math.Abs (prevAcceptedNode.X - node.X) <= 10
&& Math.Abs (prevAcceptedNode.Y - node.Y) <= 10
&& (node.X != toX || node.Y != toY))
continue; //smoothing the path
currentDirX = dirX;
currentDirY = dirY;
prevAcceptedNode = node;
yield return new AGSLocation (node.X, node.Y, to.Z);
}
}
prevNode = node;
}
}
// 寻路
public List <int> FindPath(int fx, int fy, int tx, int ty, int maxSteps, TileType tileMask)
{
var path = new List <int>();
var nodes = pathFinder.Search(fx, fy, tx, ty, new KeyValuePair <int, int>(maxSteps, (int)tileMask), true);
if (nodes != null)
{
nodes.RemoveFirst(); // remove the src node
FC.ForEach(nodes, (i, n) =>
{
path.Add((int)n.Pos.x);
path.Add((int)n.Pos.y);
}, () => path.Count < maxSteps * 2);
}
return(path);
}
private void setupWalls()
{
if (isEntrance)
{
placeExteriorWallsAndInitializeGrid();
placeStairWalls();
return;
}
// Create rooms until a valid one is complete
bool allPathsArePossible = true;
do
{
placeExteriorWallsAndInitializeGrid();
placeStairWalls();
placeInteriorWalls();
SpatialAStar <Tile, System.Object> aStar = new SpatialAStar <Tile, System.Object>(grid);
allPathsArePossible = true;
// Check to make sure all paths are possible
RoomConnection connection = roomConnections[0]; // if all can connect to this connection, then they can all connect to each other
foreach (RoomConnection otherConnection in roomConnections)
{
if (connection == otherConnection)
{
continue;
}
LinkedList <Tile> path = aStar.Search(PositionOfRoomConnection(connection), PositionOfRoomConnection(otherConnection), null);
bool pathIsPossible = path != null;
if (!pathIsPossible)
{
allPathsArePossible = false;
}
}
} while (!allPathsArePossible);
}
public bool MoveToTile(GameManager.SpecialPathNode tile)
{
path = aStar.Search(TileX, TileY, tile.X, tile.Y, null);
//Debug.Log("Enemy: " + TileX + ", " + TileY + "; Player: " + tile.X + ", " + tile.Y);
if (path != null && path.Count > 0)
{
IsMoving = true;
GoalPos = path.First.Value.tile.transform.position;
CurrentGoalNode = path.First;
LinkedListNode <GameManager.SpecialPathNode> next = path.First;
/*
* string pathStr = "";
* while (next != null)
* {
* pathStr += "(" + next.Value.X + ", " + next.Value.Y + "); ";
* next = next.Next;
* }
* //Debug.Log(pathStr);*/
return(true);
}
return(false);
}
// 寻路
public List <Vec2> FindPath(Vec2 src, Vec2 dst, int radius, params T[] ignoreUIDs)
{
var path = new List <Vec2>();
var dx = (int)dst.x;
var dy = (int)dst.y;
//if (!CheckSpareSpace(dx, dy, radius)
// && !FindNearestSpareSpace(dx, dy, radius, 1, out dx, out dy))
// return path;
var nodes = pathFinder.Search((int)src.x, (int)src.y, dx, dy, new KeyValuePair <int, T[]>(radius, ignoreUIDs), 5);
if (nodes != null)
{
nodes.RemoveFirst(); // remove the src node
foreach (var n in nodes)
{
path.Add(n.Pos);
}
}
return(path);
}
/// <summary>
/// 経路検索
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <returns></returns>
public List <PathNode> Search(Vector2Int from, Vector2Int to)
{
var res = aStar.Search(from, to, null);
return((res != null) ? res.ToList() : null);
}
private IEnumerable <PathNode> PathFinding(Point a, Point b)
{
var aStar = new SpatialAStar <PathNode, Object>(_court.ToWallGrid());
return(aStar.Search(a, b, null));
}