public void Init(int w, int h, float _tilesize)
{
// 设置耗费值和网格方位
dirX = new int[8] {
-1, 0, 1, 1, 1, 0, -1, -1
};
dirY = new int[8] {
-1, -1, -1, 0, 1, 1, 1, 0
};
Cost = new int[8] {
14, 10, 14, 10, 14, 10, 14, 10
};
width = w;
height = h;
tilesize = _tilesize;
tiles = new AStarTile[w, h];
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
tiles[x, y] = new AStarTile(x, y);
}
}
}
private void DrawTile(object sender, NodeAddedToCollectionEventArgs args)
{
mainDispatcher.Invoke(() =>
{
Node node = args.node;
AStarTile tile = AStarValues.AStarTiles[node.RowIndex, node.ColumnIndex];
if (tile == null)
{
tile = new AStarTile(node.RowIndex, node.ColumnIndex);
}
Tile tileType = tile.TileType;
if (tileType == Tile.Empty || tileType == Tile.EmptyClosed || tileType == Tile.EmptyOpen)
{
Tile newType = Tile.Empty;
if (sender is OpenSet)
{
newType = Tile.EmptyOpen;
}
else if (sender is ClosedSet)
{
newType = Tile.EmptyClosed;
}
tile.TileType = newType;
AStarValues.SetAStarTile(tile);
}
}, DispatcherPriority.Normal);
}
private void RemoveTile(object sender, MouseEventArgs e)
{
if (AStarValues.AStarState == State.HasNotStarted)
{
Point mousePosition = e.GetPosition(canvas);
double MousePosX = mousePosition.X;
double MousePosY = mousePosition.Y;
int RowIndex = GetRowIndex(MousePosY);
int ColumnIndex = GetColumnIndex(MousePosX);
AStarTile oldTile = AStarValues.AStarTiles[RowIndex, ColumnIndex];
if (oldTile == null)
{
return;
}
if (oldTile.TileType == Tile.Start)
{
AStarValues.StartTile = null;
}
else if (oldTile.TileType == Tile.Goal)
{
AStarValues.GoalTile = null;
}
var emptyTile = new AStarTile(RowIndex, ColumnIndex, Tile.Empty);
AStarValues.SetAStarTile(emptyTile);
}
}
public bool PathFind(AStarTile start, AStarTile end, List <AStarTile> except)
{
Reset(false);
Path.Clear();
PathFindSuccess = false;
PathFindCompleted = false;
PathCount = 0;
CheckStep = 0;
tileStart = start;
tileEnd = end;
tileInCheck = tileStart;
tileInCheck.open = 0;
tileInCheck.g = 0;
if (except == null)
{
tileExcept = new List <AStarTile>();
}
else
{
tileExcept = except;
}
PathCount++;
while (!PathFindCompleted)
{
PathFindSub();
}
return(PathFindSuccess);
}
private void AddTiletoOpenList(int x, int y, AStarTile prevTile)
{
AStarTile addTile = map[x, y];
if (addTile.tile.value != TileValue.Floor || closedList.Contains(addTile))
{
return;
}
if (openList.Contains(addTile))
{
if (addTile.startScore > prevTile.startScore + 1)
{
addTile.startScore = prevTile.startScore + 1;
addTile.parent = prevTile;
}
}
else
{
openList.Add(addTile);
addTile.startScore = prevTile.startScore + 1;
addTile.parent = prevTile;
addTile.finishScore = GetDistance(addTile.tile, finish.tile);
}
}
// Constructor
public AStarTile(Tile linkedTile)
{
displayTile = linkedTile;
parent = null;
distFromStart = 0;
distFromEnd = 0;
}
private void AddNeighboursToOpenList(AStarTile previousTile)
{
//left
if (previousTile.tile.x > 1)
{
AddTiletoOpenList(previousTile.tile.x - 1, previousTile.tile.y, previousTile);
}
//right
if (previousTile.tile.x < map.GetLength(0) - 2)
{
AddTiletoOpenList(previousTile.tile.x + 1, previousTile.tile.y, previousTile);
}
//down
if (previousTile.tile.y > 1)
{
AddTiletoOpenList(previousTile.tile.x, previousTile.tile.y - 1, previousTile);
}
//top
if (previousTile.tile.y < map.GetLength(1) - 2)
{
AddTiletoOpenList(previousTile.tile.x, previousTile.tile.y + 1, previousTile);
}
}
public int HeuristicCalculation(AStarTile current, AStarTile goal)
{
int manhattanValue = 100 - Mathf.RoundToInt(sliderBar.value);
int euclideanValue = Mathf.RoundToInt(sliderBar.value);
return((ManHattanDistance(current, goal) * manhattanValue) + (EuclidianDistance(current, goal) * euclideanValue));
}
public static void PerformSearch(AStarTile startingPoint, AStarTile endingPoint)
{
//Assemble the tile representation of the wordl
ms_instance.StartCoroutine(ms_instance.PerformAStarSearchCoroutine(
startingPoint,
endingPoint));
}
//Try to find the nearest path to the fruit, takes in position of the snakehead
public List <Vector2Int> CalculatePath(Vector2Int position)
{
//Clear previous calculation
tileList.Clear();
path.Clear();
currentPos = position;
sourcePos = position;
//Marks the snakehead as origin
AddInitialTile(position);
//Finds position of fruit
Vector2Int _target = FindFruit();
//Calculate costs of neighboring tiles
CheckNeighbors(position, _target);
//Find the path
while (currentPos != _target)
{
//Checks if there is any tile left to calculate, returns the lowest cost tile.
if (FindNextTile(out AStarTile _tile))
{
CheckNeighbors(_tile.position, _target);
}
//If path to fruit cannot be found, reset the list and try to find a path to the tail
else
{
tileList.Clear();
currentPos = position;
AddInitialTile(position);
CheckNeighbors(position, data.snakeList.Last.position);
while (currentPos != data.snakeList.Last.position)
{
if (FindNextTile(out _tile))
{
CheckNeighbors(_tile.position, data.snakeList.Last.position);
}
else
{
break;
}
}
break;
}
}
//Takes the last tile and tracks back to the snake
AStarTile _currentTile = tileList[currentPos];
while (_currentTile.previousTile != null)
{
path.Add(_currentTile.position);
_currentTile = _currentTile.previousTile;
}
path.Add(position);
path.Reverse();
//Return the per-tile path that the snake is to take
return(path);
}
private void AddInitialTile(Vector2Int position)
{
AStarTile _tile = new AStarTile(position);
tileList.Add(position, _tile);
_tile.explored = true;
currentPos = position;
}
private void SetGoalTile(int RowIndex, int ColumnIndex)
{
var goalTile = new AStarTile(RowIndex, ColumnIndex, Tile.Goal);
AStarValues.SetAStarTile(goalTile);
AStarValues.GoalTile = goalTile;
SetGoalTileValueChanged(this, EventArgs.Empty);
}
private void SetStartTile(int RowIndex, int ColumnIndex)
{
var startTile = new AStarTile(RowIndex, ColumnIndex, Tile.Start);
AStarValues.SetAStarTile(startTile);
AStarValues.StartTile = startTile;
SetStartTileValueChanged(this, EventArgs.Empty);
}
// Draw a line to the board.
private void DrawPathLine(AStarTile endTile)
{
AStarTile curTile = endTile;
while (curTile != null)
{
level[curTile.pos.x, curTile.pos.y].type = LevelTileType.Corridor;
curTile = curTile.prev;
}
}
private Rectangle GetRectangle(Canvas DrawingCanvas, AStarTile tile)
{
var rect = new Rectangle();
int numrows = AStarValues.NumGridRows;
int numcolumns = AStarValues.NumGridColumns;
double canvasheight = DrawingCanvas.ActualHeight;
double canvaswidth = DrawingCanvas.ActualWidth;
double rowspacing = canvasheight / numrows;
double columnspacing = canvaswidth / numcolumns;
rect.Height = rowspacing;
rect.Width = columnspacing;
rect.Stroke = new SolidColorBrush(Colors.Transparent);
rect.SnapsToDevicePixels = true;
switch (tile.TileType)
{
case Tile.Empty:
rect.Fill = new SolidColorBrush(Colors.Transparent);
break;
case Tile.EmptyClosed:
rect.Fill = RenderColors.ClosedTile;
break;
case Tile.EmptyOpen:
rect.Fill = RenderColors.OpenTile;
break;
case Tile.Start:
rect.Fill = RenderColors.StartTile;
break;
case Tile.Wall:
rect.Fill = RenderColors.WallTile;
break;
case Tile.Goal:
rect.Fill = RenderColors.GoalTile;
break;
}
double topdistance = tile.RowIndex * rowspacing;
double leftdistance = tile.ColumnIndex * columnspacing;
Canvas.SetLeft(rect, leftdistance);
Canvas.SetTop(rect, topdistance);
return(rect);
}
public Node(AStarTile tile, Node parent = null)
{
Id = Count;
Count++;
RowIndex = tile.RowIndex;
ColumnIndex = tile.ColumnIndex;
Parent = parent;
IsWalkable = !(tile.TileType == Tile.Wall);
}
private void ReconstructPath()
{
AStarTile currentTile = finish;
path.Add(finish.tile);
while (currentTile.parent != null)
{
path.Add(currentTile.parent.tile);
currentTile = currentTile.parent;
}
path.Reverse();
}
private void Render(object sender, int RowIndex, int ColumnIndex)
{
TileRenderObject oldTile = Tiles[RowIndex, ColumnIndex];
AStarTile newAStarTile = AStarValues.AStarTiles[RowIndex, ColumnIndex];
TileRenderObject newTile = new TileRenderObject(DrawingCanvas, newAStarTile);
Tiles[RowIndex, ColumnIndex] = newTile;
DrawingCanvas.Children.Add(newTile.Shape);
DrawingCanvas.Children.Remove(oldTile.Shape);
}
public void SetTileMode(int x, int y, int type)
{
AStarTile tile = tiles[x, y];
//if((type == AStarTileType.Start) && (tileStart != null)) { tileStart.SetType(0); tileStart = null; }
//if((type == AStarTileType.End ) && (tileEnd != null)) { tileEnd.SetType(0); tileEnd = null; }
tile.SetType(type);
//if(type == AStarTileType.Start) tileStart = tile;
//if(type == AStarTileType.End ) tileEnd = tile;
}
public void Reset(bool SetBlank)
{
parent = null;
open = -1;
g = 0;
h = -1;
f = 0;
if (SetBlank)
{
SetType(0);
}
}
// Overriden so the base class can be called.
protected override void Start()
{
base.Start();
aStarTiles = new AStarTile[sizeX, sizeY];
for (int x = 0; x < sizeX; x++)
{
for (int y = 0; y < sizeY; y++)
{
aStarTiles[x, y] = new AStarTile(tileGrid[x, y]);
}
}
}
public override bool CreatePath(Tile[,] map, Tile start, Tile finish)
{
openList = new List <AStarTile>();
closedList = new List <AStarTile>();
path = new List <Tile>();
ConvertMap(map);
this.start = ConvertTile(start);
this.map[start.x, start.y] = this.start;
this.finish = ConvertTile(finish);
this.map[finish.x, finish.y] = this.finish;
return(AStarPath());
}
public void PathFindSub()
{
CheckStep++;
Check(tileInCheck);
AStarTile tileMinF = null;
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
if (tiles[x, y].open != 1)
{
continue;
}
if ((tileMinF == null) || (tiles[x, y].f < tileMinF.f))
{
tileMinF = tiles[x, y];
}
}
}
if (tileMinF == null)
{
PathFindCompleted = true;
return;
}
tileInCheck = tileMinF;
tileInCheck.open = 0;
//Debug.Log ("A Star "+PathCount.ToString ()+" - "+tileInCheck.x.ToString()+","+tileInCheck.y.ToString()+",g:"+tileInCheck.g.ToString()+",h:"+tileInCheck.h.ToString()+",f:"+tileInCheck.f.ToString());
PathCount++;
if (tileInCheck == tileEnd)
{
PathFindCompleted = true;
PathFindSuccess = true;
AStarTile tileResult = tileEnd;
while (tileResult != null)
{
Path.Insert(0, GetTilePos(tileResult.x, tileResult.y));
tileResult = tileResult.parent;
}
}
}
/// <summary>
/// Assembles a path from the data stored in the AStarTileGrid, tracing the tiles using each tile's parent location.
/// </summary>
/// <param name="aStarTileGrid"></param>
/// <param name="endTile"></param>
/// <param name="startingLocation"></param>
/// <returns></returns>
private AStarPath BuildPath(ref AStarTileGrid aStarTileGrid, AStarTile endTile, Vector2Int startingLocation)
{
AStarTile priorTile = endTile;
AStarPath path = new AStarPath();
//Trace through each parent, as the path is effectively stored as a linked list, where the endTile is the start of the list.
path.AddTile(tiles[endTile.location]);
while (priorTile.location != startingLocation)
{
path.AddTile(tiles[priorTile.location]);
priorTile = aStarTileGrid[priorTile.parentLocation];
}
//The starting location is not added in the above loop, so we manually add it after
path.AddTile(tiles[startingLocation]);
return(path);
}
private void ClearTiles_Pressed(object sender, EventArgs args)
{
int numRows = AStarValues.NumGridRows;
int numColumns = AStarValues.NumGridColumns;
AStarValues.StartTile = null;
AStarValues.GoalTile = null;
for (int i = 0; i < numRows; i++)
{
for (int j = 0; j < numColumns; j++)
{
var newTile = new AStarTile(i, j, Tile.Empty);
AStarValues.SetAStarTile(newTile);
}
}
}
//Calculates the tiles G-cost
public int DistanceFromSource()
{
int _count = 0;
AStarTile _currentTile = this;
while (_currentTile.previousTile != null)
{
_count++;
_currentTile = _currentTile.previousTile;
if (_currentTile.previousTile == this)
{
throw new System.Exception("Stuck in loop");
}
}
return(_count);
}
public TileRenderer(Canvas canvas)
{
this.DrawingCanvas = canvas;
int numRows = AStarValues.NumGridRows;
int numColumns = AStarValues.NumGridColumns;
this.Tiles = new TileRenderObject[numRows, numColumns];
for (int i = 0; i < numRows; i++)
{
for (int j = 0; j < numColumns; j++)
{
var tile = new AStarTile(i, j);
Tiles[i, j] = new TileRenderObject(DrawingCanvas, tile);
}
}
}
public void Reset(bool SetBlank)
{
PathFindCompleted = false;
if (SetBlank)
{
tileStart = null;
tileEnd = null;
tileInCheck = null;
}
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
tiles[x, y].Reset(SetBlank);
}
}
}
private void SetupMap()
{
this.tiles = AStarValues.AStarTiles;
int numRows = tiles.GetLength(0);
int numColumns = tiles.GetLength(1);
this.map = new Node[numRows, numColumns];
var nodes = new Node[numRows, numColumns];
for (int row = 0; row < numRows; row++)
{
for (int col = 0; col < numColumns; col++)
{
AStarTile tile;
if (tiles[row, col] == null)
{
tile = new AStarTile(row, col);
}
else
{
tile = tiles[row, col];
}
Node node = new Node(tile);
Tile type = tile.TileType;
switch (type)
{
case Tile.Start:
StartNode = node;
break;
case Tile.Goal:
GoalNode = node;
break;
default:
break;
}
map[row, col] = node;
}
}
}
private bool AStarPath()
{
start.startScore = 0;
start.finishScore = GetDistance(start.tile, finish.tile);
start.parent = null;
closedList.Add(start);
AddNeighboursToOpenList(start);
while (openList.Count > 0)
{
AStarTile currentTile = GetLowestScoreTile();
if (currentTile.tile == finish.tile)
{
ReconstructPath();
return(true);
}
openList.Remove(currentTile);
closedList.Add(currentTile);
AddNeighboursToOpenList(currentTile);
}
return(false);
}
