AS3 高级动画教程学习之：寻路（A*算法）

A_star运算法则

相关专业术语。
节点（node）：本质上就是方形网格里的某一个方格（yujjj注：为什么不把他们描述为方格？因为在一些时候划分的节点不一定是方形的，矩形、六角形、或其它任意形状，本书中只讨论方格）。由此可以看出，路径将会由起点节点，终点节点，还有从起点到终点经过的节点组成。
代价（cost）：这是对节点优劣分级的值。代价小的节点肯定比代价大节点更好。代价由两部分组成：从起点到达当前点的代价和从这个点到终点的估计代价。代价一般由变量f，g和h，具体如下。
f：特定节点的全部代价。由g+h决定。
g：从起点到当前点的代价。它是确定的，因为你肯定知道从起点到这一点的实际路径。
h：从当前点到终点的估计代价。是用估价函数（heuristic function）计算的。它只能一个估算，因为你不知道具体的路线——你将会找出的那一条。
估价函数（heuristic）：计算从当前点到终点估计代价的公式。通常有很多这样的公式，但他们的运算结果，速度等都有差异（yujjj注：估价公式计算的估计值越接近实际值，需要计算的节点越少；估价公式越简单，每个节点的计算速度越快）。
待考察表（open list）：一组已经估价的节点。表里代价最小的节点将是下一次的计算的起点。
已考察表（closed list）：从待考察表中取代价最小的节点作为起点，对它周围8个方向的节点进行估价，然后把它放入“已考察表”。
父节点（parent node）:以一个点计算周围节点时，这个点就是其它节点的父节点。当我们到达终点节点，你可以一个一个找出父节点直到起点节点。因为父节点总是带考察表里的小代价节点，这样可以确保你找出最佳路线。
现在我们来看以下具体的运算方法：

1. 添加起点节点到待考察表
2. 主循环
a. 找到待考察表里的最小代价的节点，设为当前节点。
b. 如果当前点是终点节点，你已经找到路径了。跳到第四步。
c. 考察每一个邻节点（直角坐标网格里，有8个这样的节点 ）对于每一个邻节点： (1).如果是不能通过的节点，或者已经在带考察表或已考察表中，跳过，继续下一节点，否则继

续。

(2).计算它的代价
(3).把当前节点定义为这个点的父节点添加到待考察表
(4).添加当前节点到已考察表
3. 更新待考察表，重复第二步。
4. 你已经到达终点，创建路径列表并添加终点节点
5. 添加终点节点的父节点到路径列表
6. 重复添加父节点直到起点节点。路径列表就由一组节点构成了最佳路径

*上边内容摘自：《Flash actionScript 3.0高级动画教程》第四章 寻路

 

结合 AS3 高级动画教程学习之：等角投影笔记  的所创建的地图信息，学习A*算法 寻找最佳路径。首先得添加 Node， Grid , AStar三个类 

Node类

package com.hope.isometric
{
	/**
	 * Represents a specific node evaluated as part of p pathfinding algorithm. 
	 * @author huilin
	 * 
	 */	
	public class Node
	{
		public var x:Number;
		public var y:Number;
		public var f:Number;
		public var g:Number;
		public var h:Number;
		
		public var walkable: Boolean;
		public var parent:Node;
		public var costMultiplier:Number = 1.0;
		
		private var _object: IsoObject = null;
		
		public function Node( x: int, y: int )
		{	
			this.x = x;
			this.y = y;
		}
		
		static public function create( x: int, y: int ): Node
		{
			return new Node( x, y );
		}
		
		public function set object( value: IsoObject ): void
		{
			_object = value;
		}
		
		public function get object(): IsoObject
		{
			return _object;
		}
	}
}

 Node 类网格节点数据对象，相比《AS3 高级动画教程》我们添加 _object属性，用于记录此节点的图形。

 

Grid类:

package com.hope.isometric
{
	import mx.utils.object_proxy;

	/**
	 * Holds a two-dimensional array of Nodes method to manipulate them start node and end node for
	 * find a path.
	 *  
	 * @author huilin
	 * 
	 */	
	public class Grid
	{
		private var _startNode: Node;
		private var _endNode: Node;
		
		[ArrayElementType("Node")]
		private var _grid: Array;
		
		private var _numCols: int;
		private var _numRows: int;
		
		public function Grid( numCols: int, numRows: int)
		{
			_numCols = numCols;
			_numRows = numRows;
			
			init();
		}
		
		static public function create( numCols: int, numRows: int ): Grid
		{
			return new Grid( numCols, numRows );
		}
		
		/**
		 * Init Grid with Nodes 
		 * 
		 */		
		private function init(): void
		{
			_grid = new Array();
			
			for( var i: int = 0; i < _numCols; i++ )
			{
				_grid[ i ] = new Array();
				
				for( var j:int = 0; j < _numRows; j++ )
				{
					_grid[i][j] = Node.create( i, j );
				}
			}
		}
		
		/**
		 * 
		 * @param x The x coordinate.
		 * @param y The y coordinate.
		 * @return The Node at the given coordinate.
		 * 
		 */		
		public function getNode( x: int, y:int ): Node
		{
			return _grid[x][y] as Node;
		}
		
		/**
		 * Sets the Node at the given coordinate as startNode.
		 * @param x The x coordinate.
		 * @param y The y coordinate.
		 * 
		 */		
		public function setStartNode( x: int, y: int ): void
		{
			_startNode = _grid[x][y];
		}
		
		
		/**
		 * Sets the Node at the given coordinate as endNode.
		 * @param x The x coordinate.
		 * @param y The y coordinate.
		 * 
		 */		
		public function setEndNode( x: int, y: int ): void
		{
			_endNode = _grid[x][y];
		}
		
		/**
		 * Sets the node at the given coords as walkable or not.
		 * @param x The x coord.
		 * @param y The y coord.
		 */
		public function setWalkable(x:int, y:int, value:Boolean):void
		{
			_grid[x][y].walkable = value;
		}
		
		
		
		// getters / setters
		
		/**
		 * Returns the start node.
		 */
		public function get startNode():Node
		{
			return _startNode;
		}
		
		/**
		 * Returns the end node.
		 */
		public function get endNode():Node
		{
			return _endNode;
		}
		
		/**
		 * Returns the number of columns in the grid.
		 */
		public function get numCols():int
		{
			return _numCols;
		}
			
		/**
		 * Returns the number of rows in the grid.
		 */
		public function get numRows():int
		{
			return _numRows;
		}	
		
		public function setNodeObject( x: int, y: int, value: IsoObject ): void
		{
			setWalkable( x, y, value.walkable );
			_grid[x][y].object = value;
		}
	}
}

Grid类使用二维数据（_grid ）保存所有网格节点的数据信息。

AStar类

package com.hope.isometric
{
	/**
	 * A*算法 
	 * @author huilin
	 * 
	 */	
	import com.hope.isometric.Node;
	
	public class AStar
	{	
		[ArrayElementType("Node")]
		private var _openList: Array;   //待考察表
		
		[ArrayElementType("Node")]
		private var _closedList: Array;  //已考察表
		
		private var _grid: Grid;
		
		private var _startNode: Node;
		private var _endNode: Node;
		
		[ArrayElementType("Node")]
		private var _path: Array;
		
		private var _heuristic: Function = diagonal;
		private var _straightCost: Number = 1.0;
		private var _diagCost: Number = Math.SQRT2;
		
		public function AStar()
		{
		}
		
		static public function create(): AStar
		{
			return new AStar();
		}
		
		public function findPath( grid: Grid ): Boolean
		{	
			_grid = grid;
			
			_openList = new Array();
			_closedList = new Array();
			
			_startNode = _grid.startNode;
			_endNode = _grid.endNode;
			
			_startNode.g = 0;
			_startNode.h = _heuristic( _startNode );
			_startNode.f = _startNode.g + _startNode.h;
			
			return search();
		}
		
		private function search(): Boolean
		{
			var currentNode: Node = _startNode;
			
			while( currentNode != _endNode )
			{
				//_openList = [];  //当前待考察列表
				
				var startX: int = Math.max( 0, currentNode.x - 1 );
				var endX: int = Math.min( _grid.numCols - 1, currentNode.x + 1 );
				
				var startY: int = Math.max( 0, currentNode.y -1 );
				var endY: int = Math.min( _grid.numRows - 1, currentNode.y + 1 );
				
				//check Nodes from ( startX, startY ) to (endX, endY );
				for( var i:int = startX; i <= endX; i++ )
				{
					trace( "...................................." + i );
					for( var j:int = startY; j <= endY; j++ )
					{
						var node: Node = _grid.getNode( i, j );
						trace( "node: " + node.x + " " + node.y )
						
						if ( validNode( node, currentNode ) )
						{		
							var cost: Number = _diagCost;
							
							if ( currentNode.x == node.x || currentNode.y == node.y )
							{
								cost = _straightCost;
							}
							
							var g: Number = currentNode.g + cost * node.costMultiplier;
							var h: Number = _heuristic( node );
							var f: Number = g + h;
							
							if( isOpen( node ) || isClosed( node ) )
							{
								if ( node.f > f )
								{
									node.f = f;
									node.g = g;
									node.h = h;
									node.parent = currentNode
								}
							}else
							{
								node.f = f;
								node.g = g;
								node.h = h;
								
								node.parent = currentNode;
								_openList.push( node );
							}
						}	
					}
				}	
				
				_closedList.push( currentNode );  //已考察列表
				
				if ( _openList.length == 0 )
				{
					trace( "no path found!" );
					return false;
				}
					
				_openList.sortOn( "f", Array.NUMERIC );
				currentNode = _openList.shift() as Node;
				
				trace( "find node: " + currentNode.x + " " + currentNode.y + " f:" + currentNode.f )
			}
				
			buildPath();
			
			return true;
		}
		
		private function validNode( node: Node, currentNode: Node ): Boolean
		{
			if( currentNode == node || !node.walkable ) return false;
			
			if ( !_grid.getNode( currentNode.x, node.y ).walkable ) return false;
			
			if ( !_grid.getNode( node.x, currentNode.y ).walkable ) return false;
				
			return true;
		}
		
		private function isOpen( node: Node ): Boolean
		{
			return _openList.indexOf( node ) > 0 ? true : false;
		}
		
		private function isClosed( node: Node ): Boolean
		{
			return _closedList.indexOf( node ) > 0 ? true : false;
		}
		
		private function buildPath(): void
		{
			trace( "buildPath" );
			_path = new Array();
			
			var node: Node = _endNode;
			_path.push( node );
			
			while( node != _startNode )
			{
				node = node.parent;
				_path.unshift( node );
			}
		}
		
		private function manhattan( node: Node ): Number
		{
			return Math.abs( _endNode.x - node.x )*_straightCost + Math.abs( _endNode.y - node.y )*_straightCost;
		}
		
		private function euclidian( node: Node ): Number
		{
			var dx: Number = _endNode.x - node.x;
			var dy: Number = _endNode.y - node.y;
			
			return Math.sqrt(dx*dx + dy*dy ) * _straightCost;
		}
		
		
		private function diagonal( node: Node ): Number
		{
			var dx: Number = Math.abs( _endNode.x - node.x );
			var dy: Number = Math.abs( _endNode.y - node.y );
			
			var diag: Number = Math.min( dx, dy );
			var straight: Number = dx + dy;
			
			return _diagCost * diag + _straightCost * ( straight - 2*diag );
		}
		
		//
		///setter / getter
		
		public function get grid(): Grid
		{
			return _grid;
		}
		
		public function set grid( value: Grid ): void
		{
			_grid = value;
		}
		
		public function get openList() : Array
		{
			return _openList;
		}
		
		public function set openList( value: Array ): void
		{
			_openList = value;
		}
		
		public function get closedList() : Array
		{
			return _closedList;
		}
		
		public function set closedList( value: Array ): void
		{
			_closedList = value;
		}
		
		public function get path(): Array
		{
			return _path;
		}
	}
}

主角登场，AStar类, 从开始节点开始，一次一次的循环，查询当前节点的相领节点。当当前节点为终点节点时，整个计算结束，退出循环。

当前节点的相邻节点

 

修改IsoWorld类：

package com.hope.isometric
{
	import flash.display.DisplayObject;
	import flash.display.Sprite;
	import flash.events.MouseEvent;
	import flash.geom.Point;
	import flash.utils.Dictionary;

//	http://www.java3z.com/cwbwebhome/article/article2/2825.html
	public class IsoWorld extends Sprite
	{
		private var grid: Grid;
		private var cellSize: Number;
		
		private var floor: Sprite;
		private var world: Sprite;
			
		[ArrayElementType("IsoObject")]
		private var objectList: Array;
		
		private var numCols: int = 10;
		private var numRows: int = 10;
		
		public function IsoWorld()
		{
		}
		
		static public function create(): IsoWorld
		{
			return new IsoWorld();
		}
				
		/**
		 * 
		 * @param size The tile size to user when making the world
		 * @return A fully populated IsoWorld instance
		 * 
		 */		
		public function makeWorld( size: Number, mapGrid: Array, tileTypes: Dictionary ): void
		{
			//cellSize = size;
			numCols = mapGrid.length;
			numRows = mapGrid[0].length;
			
			createGrid( size );
			
			for( var i:int = 0; i < mapGrid.length; i++ )
			{
				for( var j:int = 0; j < mapGrid[i].length; j++ )
				{
					var cellType: String = mapGrid[i][j] as String;
					var cell: Object = tileTypes[ cellType ];
					
					var tile: IsoObject = IsoObject.create( cell.type );
					
					tile.draw(size, parseInt(cell.color), parseInt(cell.height));
					tile.walkable = cell.walkable == "true" ? true:false;
					
					tile.position = new Point3D( j * 20, 0, i * 20 );
					
					grid.setNodeObject( j, i, tile );
					
					addChild( tile );	
				
					//trace( "tile type:" + cell.type + " x:" + i + " y:" + j  + " walkable:" + tile.walkable +  " " + grid.getNode(j,i).walkable );
				}
			}
		}
		
	
		private function createGrid( size: Number ): void
		{
			cellSize = size;
			grid = Grid.create( numCols, numRows );
		}
						
		public function setPosition( x: Number, y: Number ): void
		{
			this.x = x;
			this.y = y;
		}
			
		public function findPath( startNode: Node, endNode: Node ): void
		{
			var astar: AStar = AStar.create();
			
			grid.setStartNode( startNode.x, startNode.y );
			grid.setEndNode( endNode.x, endNode.y );
			
			if ( astar.findPath( grid ))
			{
				trace( "find Path..." );
				
				for( var i:int = 0; i < astar.path.length; i++ )
				{
					var node: Node = astar.path[i] as Node;
					trace( "node " + i + " [ " + node.x + "," + node.y + " ]" );
					
					var tile: IsoObject = node.object;
					
					var color: uint = 0x0000ff;
					if ( i == 0 ) //startNode
						color = 0xff0000;
					else if( i == astar.path.length - 1 )  //endNode
						color = 0xffff00;
								
					tile.draw( tile.size, color, tile.height );
				}
			}
			else
			{
				trace( "not found path..." );
			}
		}
		
	}
}

在IsoWorld添加 createGrid，findPath函数.

并在makeWorld 调用 createGrid访求，并通过grid.setNodeObject( )访使得网格节点与图形关联.

修改IsoWorldTest类

package com.hope.isometric
{
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.Point;
	import flash.net.URLRequest;

	
	public class IsoWorldTest extends Sprite
	{
		private var world: IsoWorld;
		private var mapLoader: MapLoader;
		private var astar: AStar;
		
		public function IsoWorldTest()
		{
			if( stage )
				init();
			else
				addEventListener( Event.ADDED_TO_STAGE, init );
		}
		
		private function init( event: Event = null ): void
		{
			removeEventListener( Event.ADDED_TO_STAGE, init );
			
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;
		
			loadMap();		
		}
		
		private function loadMap(): void
		{
			mapLoader = new MapLoader();
			mapLoader.addEventListener( Event.COMPLETE, onMapComplete );
			mapLoader.loadMap( "map.txt" );	
		}
		
		private function onMapComplete( event: Event ): void
		{
			trace( "load complete" );
			world = IsoWorld.create();
			
			world.makeWorld( 20, mapLoader.mapGrid, mapLoader.tileTypes );
			
			addChild( world );
			world.setPosition( 500, 200 );
				
			
			world.findPath( new Node( 18, 15 ), new Node( 6, 6) );
		}
	}
}

 

修改测试类IsoWorldTest，在onMapComplete中添加

world.findPath( new Node( 18, 15 ), new Node( 6, 6) );

一行代码，定义的开始节点，终点节点。调用findPath开始寻路.

最后运行结果: 红色为起始节点，黄色为终点节点，蓝色为路径过程节点。