unityA* 寻路算法，使用OnGUI()函数

A*（A-Star)算法是一种静态路网中求解最短路最有效的直接搜索方法。
注意是最有效的直接搜索算法。之后涌现了很多预处理算法（ALT，CH，HL等等），在线查询效率是A*算法的数千甚至上万倍。
公式表示为： f(n)=g(n)+h(n)
其中 f(n) 是从初始点经由节点n到目标点的估价函数，
g(n) 是在状态空间中从初始节点到n节点的实际代价，
h(n) 是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解的）条件，关键在于估价函数f(n)的选取：
估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。并且如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。
如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;

/// <summary>
/// 格子类型
/// </summary>
public enum GridType
{
Normal,
Obstacle,
Start,
End
}
/// <summary>
/// 为了实现格子的排序，继承ICompareable
/// </summary>
public class MapGrid:IComparable
{
/// <summary>
/// 记录坐标
/// </summary>
public int x;
public int y;

/// <summary>
/// 总消耗
/// </summary>
public int f;
/// <summary>
/// 当前到起点的消耗
/// </summary>
public int g;
//当前到终点的消耗
public int h;

public GridType type;
/// <summary>
/// 父节点
/// </summary>
public MapGrid fatherNode;

/// <summary>
/// 排序
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public int CompareTo(object obj)
{
MapGrid grid = (MapGrid)obj;
if(this .f <grid .f)
{
//升序
return -1;
}
if(this .f >grid .f)
{
//降序
return 1;
}
return 0;
}
}

public class AStar : MonoBehaviour {

public int row = 5;
public int col = 10;
//格子大小
public int size = 70;

public MapGrid[,] grids;
public ArrayList openList;
public ArrayList closeList;

//开始和结束的位置
private int xStart = 2;
private int yStart = 1;
private int xEnd = 2;
private int yEnd = 5;

private Stack<string> fatherNodeLocation;

void Init()
{
grids = new MapGrid[row, col];

for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
//初始化格子，记录格子的坐标
grids[i, j] = new MapGrid();
grids[i, j].x = i;
grids[i, j].y = j;
}
}
//开始点和其h的值
grids[xStart, yStart].type = GridType.Start;
grids[xStart, yStart].h = Manhatten(xStart, yStart);

grids[xEnd, yEnd].type = GridType.End;

fatherNodeLocation = new Stack<string>();

for (int i = 1; i <= 3; i++)
{
grids[i, 3].type = GridType.Obstacle;
}

openList = new ArrayList();
openList.Add(grids[xStart, yStart]);

closeList = new ArrayList();
}

private int Manhatten(int x,int y)
{
return (int)(Math.Abs(xEnd - x) + Math.Abs(yEnd - y)) * 10;
}

void Start()
{
Init();
}

void DrawGrid()
{
for (int i = 0; i < row ; i++)
{
for (int j = 0; j < col ; j++)
{
Color color = Color.yellow;
if(grids [i,j].type ==GridType .Start )
{
color = Color.green;
}
else if(grids [i,j].type ==GridType .Start )
{
color = Color.red;
}
else if (grids [i,j].type ==GridType .Obstacle )
{
color = Color.blue;
}
else if(closeList .Contains (grids [i,j]))
{
color = Color.yellow;
}
else
{
color = Color.grey;
}

GUI.backgroundColor = color;
GUI.Button(new Rect(j * size, i * size, size, size), FGH(grids[i, j]));
}
}
}

private string FGH(MapGrid grid)
{
string str = "F" + grid.f + "\n";
str += "G" + grid.g + "\n";
str += "H" + grid.h + "\n";
str += "(" + grid.x + "," + grid.y + ")";
return str;
}

void OnGUI()
{
DrawGrid();
for (int i = 0; i < openList .Count ; i++)
{
GUI.Button(new Rect(i * size, (row + 1) * size, size, size), FGH((MapGrid)openList[i]));
}

for (int j = 0; j < closeList .Count ; j++)
{
GUI.Button(new Rect(j * size, (row + 1) * size, size, size), FGH((MapGrid)closeList[j]));
}

if(GUI .Button (new Rect (col *size ,size ,size ,size ),"next"))
{
NextStep();
}
}

private void NextStep()
{
if (openList.Count == 0)
{
print("over !");
return;
}

MapGrid grid=(MapGrid )openList [0];
if(grid.type ==GridType .End )
{
print ("find");
ShowFatherNode(grid);
return ;
}

for (int i = -1; i <=1; i++)
{
for (int j = -1; j <=1; j++)
{
int x = grid.x + i;
int y = grid.y + j;

if(x>=0&&x<row &&y>=0&&y<col&&
grids [x,y].type !=GridType .Obstacle &&
!closeList .Contains (grids[x,y]))
{
int g = grid.g + (int)(Math.Sqrt((Math.Abs(i) + Math.Abs(j))) * 10);
if(grids[x,y].g==0||grids [x,y].g>g)
{
grids[x, y].g = g;
grids[x, y].fatherNode = grid;
}

grids[x, y].h = Manhatten(x, y);
grids[x, y].f = grids[x, y].g + grids[x, y].h;

if(!openList .Contains (grids[x,y]))
{
openList.Add(grids[x, y]);
}

openList.Sort();
}
}
}

closeList.Add(grid);
openList.Remove(grid);
}

private void ShowFatherNode(MapGrid grid)
{
if(grid.fatherNode !=null )
{
string str = grid.fatherNode.x + "," + grid.fatherNode.y;
fatherNodeLocation.Push(str);
ShowFatherNode(grid.fatherNode);
}

if(fatherNodeLocation .Count !=0)
{
print(fatherNodeLocation.Pop());
}
}
}


原文链接：点击打开链接