AS3 AStar算法（1）
Flash AS3 2009-12-03 17:25:44 阅读119 评论0 字号：大中小
最近再次看了一下AStar算法，并把理论转化成了代码。后来在一个2.5D的格子上测试了一把，哈哈，很不错。
先说理论：
A-Star算法是一种静态路网中求解最短路最有效的方法。简单的说，就是从起点开始，计算出经过周围节点的代价。找到一条代价最小的通向终点的路径。整个过程就是不断把周围代价最小的节点作为新的起点，最后达终点，同时找到最佳路径。
上面说的节点，在网格中就是一个方格，不过也可以是其他形状，比如六边形。另外一个就是代价，代价包含两个方面的意思：从起点到当前点的代价和当前点到终点的估计代价。这两个代价值加起来就是当前点的总代价了。
通常用公式表示为：f = g + h.
g就是从起点到当前点的代价。
h是当前点到终点的估计代价，是通过估价函数计算出来的。这个函数可以说是整个算法的关键了，因为算法的不同直接影响最终结果，以及算法的效率。这里有一个简单而有效算法，对于简单的网格来说就是计算当前网格到终点的距离:Math.sqrt(dx*dx+dy*dy);
搜索过程是这样的：
有两个数组，openList（带考察表）存放已经估价的节点，其中代价最小的节点是下一次计算的起点。closedList（已考察表）存放从待考察表中取出的代价最小的节点，在对其周围的各个节点进行估价后就将其放入closedList。
对于每个节点都会有一个父节点，以一个点计算周围节点时，这个点就是其它节点的父节点。到达终点时，就通过每一个点的父节点一直找到起点。路径也就找到了。
计算代价：
对于一个不再边上的节点，他周围会有8个节点，可以看成他到周围8个点的代价都是1。精确点，到上下左右4个点的代价是1，到左上左下右上右下的1.414就是“根号2”，这个值就是前面说的g。大概就是下面这个样子
2.8 2.4 2 2.4 2.8
2.4 1.4 1 1.4 2.4
2 1 0 1 2
2.4 1.4 1 1.4 2.4
2.8 2.4 2 2.4 2.8
对于h，需要用一个估价函数来计算，前面有说到一个简单算法就是计算直线距离。假设终点是（50，50），对于点（20，30）来说我们用前面提到的估价函数来计算的话就是这样：
dx = 50 - 20 = 30;
dy = 50 - 30 = 20;
h = Math.sqrt(dx * dx + dy * dy) = 36.1
理论好像差不多了。接下来就是代码来。
AS3 AStar算法（2）
Flash AS3 2009-12-03 22:31:34 阅读82 评论0 字号：大中小
前面说了理论，该开始写代码来。首先，构造一个节点类AStarNode:
package com.cyy.astar
{
/**
* ...
* @author Will Chen
* @version 1.0
* @email c_youyou@163.com
* @msn chenyouyou@live.cn
* @description ...
*/
public class AStarNode
{
public var x:int;
public var y:int;
public var f:Number;
public var g:Number;
public var h:Number;
public var parent:AStarNode;
public var isEmpty:Boolean = true;
public function AStarNode(x:int, y:int)
{
this.x = x;
this.y = y;
}
}
}
接着是网格类AStarGrid:
package com.cyy.astar
{
/**
* ...
* @author Will Chen
* @version 1.0
* @email c_youyou@163.com
* @msn chenyouyou@live.cn
* @description ...
*/
public class AStarGrid
{
public var startNode:AStarNode;
public var endNode:AStarNode;
public var nodes:Array;
public var columnNum:int;
public var rowNum:int;
public function AStarGrid(columnNum:int, rowNum:int)
{
this.columnNum = columnNum;
this.rowNum = rowNum;
nodes = new Array();
for(var i:int = 0; i < columnNum; i++)
{
nodes[i] = new Array();
for(var j:int = 0; j < rowNum; j++)
{
nodes[i][j] = new AStarNode(i, j);
}
}
}
public function getNode(x:int, y:int):AStarNode
{
return nodes[x][y];
}
public function setEndNode(x:int, y:int):AStarNode
{
if (x < this.columnNum && y < this.rowNum)
{
endNode = nodes[x][y];
}
else
{
endNode = null;
}
return endNode;
}
public function setStartNode(x:int, y:int):AStarNode
{
if (x < this.columnNum && y < this.rowNum)
{
startNode = nodes[x][y];
}
else
{
startNode = null;
}
return startNode;
}
public function setNodeEmpty(x:int, y:int, value:Boolean):void
{
nodes[x][y].isEmpty = value;
}
}
}
然后就是AStar：
package com.cyy.astar
{
/**
* ...
* @author Will Chen
* @version 1.0
* @email c_youyou@163.com
* @msn chenyouyou@live.cn
* @description ...
*/
public class AStar
{
private var openList:Array;
private var closedList:Array;
private var _path:Array;
private var grid:AStarGrid;
private var endNode:AStarNode;
private var startNode:AStarNode;
private var costOne:Number = 1;
private var costSqrt:Number = Math.SQRT2;
public function AStar()
{
}
public function findPath(grid:AStarGrid):Boolean
{
this.grid = grid;
openList = new Array();
closedList = new Array();
grid.startNode.g = 0;
grid.startNode.h = getH(grid.startNode);
grid.startNode.f = grid.startNode.g + grid.startNode.h;
return begin();
}
private function begin():Boolean
{
var node:AStarNode = grid.startNode;
while (node != grid.endNode)
{
var beginX:int = node.x == 0 ? 0 : node.x - 1;
var endX:int = node.x == grid.columnNum - 1 ? grid.columnNum - 1 : node.x + 1;
var beginY:int = node.y == 0 ? 0 : node.y - 1;
var endY:int = node.y == grid.rowNum - 1 ? grid.rowNum - 1 : node.y + 1;
for (var i:int = beginX; i <= endX; i++)
{
for (var j:int = beginY; j <= endY; j++)
{
var currentNode:AStarNode = grid.getNode(i, j);
if (currentNode == node || !currentNode.isEmpty
|| (!grid.getNode(node.x, currentNode.y).isEmpty && !grid.getNode(currentNode.x, node.y).isEmpty))
{
continue;
}
var cost:Number = costOne;
if (!((node.x == currentNode.x) || (node.y == currentNode.y)))
{
cost = costSqrt;
}
var g:Number = node.g + cost;
var h:Number = getH(currentNode);
var f:Number = g + h;
if (openList.indexOf(currentNode) == -1 && closedList.indexOf(currentNode) == -1)
{
currentNode.f = f;
currentNode.g = g;
currentNode.h = h;
currentNode.parent = node;
openList.push(currentNode);
}
}
}
closedList.push(node);
if (openList.length == 0)
{
return false
}
openList.sortOn("f", Array.NUMERIC);
node = openList.shift();
}
_path = new Array();
node = grid.endNode;
_path.push(node);
while (node != grid.startNode)
{
node = node.parent;
_path.unshift(node);
}
return true;
}
private function getH(node:AStarNode):Number
{
var dx:Number = node.x - grid.endNode.x;
var dy:Number = node.y - grid.endNode.y;
return Math.sqrt(dx * dx + dy * dy);
}
public function get path():Array { return _path; }
}
}
OK，完成，核心代码就这么多了，不过还有很多地方可以优化。
下次再写一个测试用的类
AS3 AStar算法（3）
Flash AS3 2009-12-04 10:30:32 阅读79 评论0 字号：大中小
开始测试。。。不多说，看代码：
package
{
import com.cyy.astar.AStar;
import com.cyy.astar.AStarGrid;
import com.cyy.astar.AStarNode;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
/**
* ...
* @author Will Chen
* @version 1.0
* @email c_youyou@163.com
* @msn chenyouyou@live.cn
* @description ...
*/
public class AStarTest extends Sprite
{
private var player:Sprite;
private var grid:AStarGrid;
private var index:int;
private var path:Array;
private var speed:Number = 0.5;
public function AStarTest()
{
player = new Sprite();
player.graphics.beginFill(0x0000ff);
player.graphics.drawCircle(0, 0, 5);
player.graphics.endFill();
player.x = 310;
player.y = 310;
addChild(player);
grid = new AStarGrid(50, 50);
for (var i:int = 0; i < 500; i++)
{
grid.setNodeEmpty(Math.floor(Math.random() * 50), Math.floor(Math.random() * 50), false);
}
drawGrid();
stage.addEventListener(MouseEvent.CLICK, onStageClickHandler);
}
private function drawGrid():void
{
graphics.clear();
for (var i:int = 0; i < grid.columnNum; i++)
{
for (var j:int = 0; j < grid.rowNum; j++)
{
graphics.lineStyle(0);
graphics.beginFill(getColor(grid.getNode(i, j)));
graphics.drawRect(i * 20, j * 20, 20, 20);
graphics.endFill();
}
}
}
private function getColor(node:AStarNode):uint
{
if (!node.isEmpty)
{
return 0x000000;
}
if (node == grid.startNode || node == grid.endNode)
{
return 0x00ff00;
}
return 0xffffff;
}
private function onStageClickHandler(event:MouseEvent):void
{
var posX:int = Math.floor(mouseX / 20);
var posY:int = Math.floor(mouseY / 20);
grid.setEndNode(posX, posY);
posX = Math.floor(player.x / 20);
posY = Math.floor(player.y / 20);
grid.setStartNode(posX, posY);
drawGrid();
getPath();
}
private function getPath():void
{
var astar:AStar = new AStar();
if (astar.findPath(grid))
{
path = astar.path;
index = 1;
addEventListener(Event.ENTER_FRAME, onEnterFrameHandler);
}
else
{
trace("not found the path!!!");
}
}
private function onEnterFrameHandler(e:Event):void
{
var pathX:Number = path[index].x * 20 + 20 / 2;
var pathY:Number = path[index].y * 20 + 20 / 2;
var dx:Number = pathX - player.x;
var dy:Number = pathY - player.y;
var temp:Number = Math.sqrt(dx * dx + dy * dy);
if (temp < 1)
{
index++;
if (index == path.length)
{
removeEventListener(Event.ENTER_FRAME, onEnterFrameHandler);
}
}
else
{
player.x += dx * speed;
player.y += dy * speed;
}
}
}
}
直接编译就能跑了，貌似还不错，呵呵