AStar A* A星 算法TypeScript版本

一 演示效果

二  参考教程

《ActionScript3.0 高级动画教程》 + 源码

http://download.****.net/download/zhengchengpeng/7756023

三 AStar源码

Main.ts新建Game，即可看Demo

  this.addChild(new Game())

源码地址：

https://files.cnblogs.com/files/gamedaybyday/astar_ts.rar

AStar核心类

/**
 * A星寻路
 * @author chenkai
 * @since 2017/11/3
 */
namespace astar{
    export class AStar
    {
        private _open:Array<any>;               //待考察表
        private _closed:Array<any>;             //已考察表
        private _grid:astar.Grid;               //网格
        private _endNode:Node;                  //终点Node
        private _startNode:Node;                //起点Node
        private _path:Array<any>;               //保存路径
        private _heuristic:Function;            //寻路算法
        private _straightCost:number = 1.0;     //上下左右走的代价
        private _diagCost:number = Math.SQRT2;  //斜着走的代价 

        public constructor()
        {
            //this._heuristic = this.manhattan;
            //this._heuristic = this.euclidian;
            this._heuristic = this.diagonal;
        }

        //寻路
        public findPath(grid:Grid):boolean
        {
            this._grid = grid;
            this._open = [];
            this._closed = [];

            this._startNode = this._grid.startNode;
            this._endNode = this._grid.endNode;

            this._startNode.g = ;
            this._startNode.h = this._heuristic(this._startNode);
            this._startNode.f = this._startNode.g + this._startNode.h;

            return this.search();
        }

        //查找路径
        public search():boolean
        {
            var node:Node = this._startNode;
            while(node != this._endNode)
            {
                var startX = Math.max(, node.x - );
                var endX = Math.min(this._grid.numCols - , node.x + );
                var startY = Math.max(, node.y - );
                var endY = Math.min(this._grid.numRows - , node.y + );

                for(var i = startX; i <= endX; i++)
                {
                    for(var j = startY; j <= endY; j++)
                    {
                        //不让斜着走
                        if(i != node.x && j != node.y){
                            continue;
                        }

                        var test:Node = this._grid.getNode(i, j);
                        if(test == node ||
                            !test.walkable ||
                            !this._grid.getNode(node.x, test.y).walkable ||
                            !this._grid.getNode(test.x, node.y).walkable)
                        {
                            continue;
                        }

                        var cost:number = this._straightCost;
                        if(!((node.x == test.x) || (node.y == test.y)))
                        {
                            cost = this._diagCost;
                        }
                        var g = node.g + cost * test.costMultiplier;
                        var h = this._heuristic(test);
                        var f = g + h;
                        if(this.isOpen(test) || this.isClosed(test))
                        {
                            if(test.f > f)
                            {
                                test.f = f;
                                test.g = g;
                                test.h = h;
                                test.parent = node;
                            }
                        }
                        else
                        {
                            test.f = f;
                            test.g = g;
                            test.h = h;
                            test.parent = node;
                            this._open.push(test);
                        }
                    }
                }
                for(var o = ; o < this._open.length; o++)
                {
                }
                this._closed.push(node);
                if(this._open.length == )
                {
                    console.log("AStar >> no path found");
                    return false
                }

                let openLen = this._open.length;
                for(let m=;m<openLen;m++){
                    for(let n=m+;n<openLen;n++){
                        if(this._open[m].f > this._open[n].f){
                            let temp = this._open[m];
                            this._open[m] = this._open[n];
                            this._open[n] = temp;
                        }
                    }
                }

                node = this._open.shift() as Node;
            }
            this.buildPath();
            return true;
        }

        //获取路径
        private buildPath():void
        {
            this._path = new Array();
            var node:Node = this._endNode;
            this._path.push(node);
            while(node != this._startNode)
            {
                node = node.parent;
                this._path.unshift(node);
            }
        }

        public get path()
        {
            return this._path;
        }

        //是否待检查
        private isOpen(node:Node):boolean
        {
            for(var i = ; i < this._open.length; i++)
            {
                if(this._open[i] == node)
                {
                    return true;
                }
            }
            return false;
        }

        //是否已检查
        private isClosed(node:Node):boolean
        {
            for(var i = ; i < this._closed.length; i++)
            {
                if(this._closed[i] == node)
                {
                    return true;
                }
            }
            return false;
        }

        //曼哈顿算法
        private manhattan(node:Node)
        {
            return Math.abs(node.x - this._endNode.x) * this._straightCost + Math.abs(node.y + this._endNode.y) * this._straightCost;
        }

        private euclidian(node:Node)
        {
            var dx = node.x - this._endNode.x;
            var dy = node.y - this._endNode.y;
            return Math.sqrt(dx * dx + dy * dy) * this._straightCost;
        }

        private diagonal(node:Node)
        {
            var dx = Math.abs(node.x - this._endNode.x);
            var dy = Math.abs(node.y - this._endNode.y);
            var diag = Math.min(dx, dy);
            var straight = dx + dy;
            return this._diagCost * diag + this._straightCost * (straight -  * diag);
        }

        public get visited()
        {
            return this._closed.concat(this._open);
        }
    }

}

Grid网格

/**
 * 网格类
 * @author chenkai
 * @since 2017/11/3
 */
namespace astar{
    export  class Grid {
        private _startNode:Node;    //起点
        private _endNode:Node;      //终点
        private _nodes:Array<any>;  //Node数组
        private _numCols:number;    //网格行列
        private _numRows:number;

        public constructor(numCols:number, numRows:number) {
            this._numCols = numCols;
            this._numRows = numRows;
            this._nodes = [];

            for(let i:number=;i<numCols;i++){
                this._nodes[i] = [];
                for(let j:number=;j<numRows;j++){
                    this._nodes[i][j] = new Node(i,j);
                }
            }
        }

        public getNode(x:number , y:number):Node{
            return this._nodes[x][y];
        }

        public setEndNode(x:number, y:number){
            this._endNode = this._nodes[x][y];
        }

        public setStartNode(x:number, y:number){
            this._startNode = this._nodes[x][y];
        }

        public setWalkable(x:number, y:number, value:boolean){
            this._nodes[x][y].walkable = value;
        }

        public get endNode(){
            return this._endNode;
        }

        public get numCols(){
            return this._numCols;
        }

        public get numRows(){
            return this._numRows;
        }

        public get startNode(){
            return this._startNode;
        }
    }
}

Node节点

/**
 * Node 节点
 * @author chenkai
 * @since 2017/11/3
 */
namespace astar{
    export class Node {
        public x:number;    //列
        public y:number;    //行
        public f:number;    //代价 f = g+h
        public g:number;    //起点到当前点代价
        public h:number;    //当前点到终点估计代价
        public walkable:boolean = true;
        public parent:Node;
        public costMultiplier:number = 1.0;

        public constructor(x:number , y:number) {
            this.x = x;
            this.y = y;
        }
    }
}

演示Demo

class Game extends egret.Sprite
{
    private _cellSize:number = ;
    private _grid:astar.Grid;
    private _player:egret.Sprite;
    private _index:number;
    private _path:Array<any>;

    public constructor()
    {
        super();
        this.makePlayer();
        this.makeGrid();
        this.addEventListener(egret.Event.ADDED_TO_STAGE, ()=>{
            this.stage.addEventListener(egret.TouchEvent.TOUCH_TAP, this.onGridClick, this);
        },this);

    }

    /**
     * Creates the player sprite. Just a circle here.
     */
    private makePlayer()
    {
        this._player = new egret.Sprite();
        this._player.graphics.beginFill(0xff0000);
        this._player.graphics.drawCircle(, , );
        this._player.graphics.endFill();
        this._player.x = Math.random() * ;
        this._player.y = Math.random() * ;
        this.addChild(this._player);
    }

    /**
     * Creates a grid with a bunch of random unwalkable nodes.
     */
    private makeGrid():void
    {
        this._grid = new astar.Grid(,);
        for(var i = ; i < ; i++)
        {
            this._grid.setWalkable(Math.floor(Math.random() * ),
                                Math.floor(Math.random() * ),
                                false);
        }
        this.drawGrid();
    }

    /**
     * Draws the given grid, coloring each cell according to its state.
     */
    private drawGrid():void
    {
        this.graphics.clear();
        for(let i = ; i < this._grid.numCols; i++)
        {
            for(let j = ; j <this._grid.numRows; j++)
            {
                var node:astar.Node =this._grid.getNode(i, j);
                //这里有Bug, 绘制将近150次时， drawRect会出错
                // this.graphics.lineStyle(0);
                // this.graphics.beginFill(this.getColor(node));
                // this.graphics.drawRect(i * this._cellSize, j * this._cellSize, this._cellSize, this._cellSize);
                let sp:egret.Sprite = new egret.Sprite();
                sp.graphics.beginFill(this.getColor(node));
                sp.graphics.drawRect(,,,);
                sp.graphics.endFill();
                sp.x = i*this._cellSize;
                sp.y = j*this._cellSize;
                this.addChild(sp);
            }
        }
        this.addChild(this._player);
    }

    /**
     * Determines the color of a given node based on its state.
     */
    private getColor(node:astar.Node)
    {
        if(!node.walkable) return ;
        if(node == this._grid.startNode) return 0xcccccc;
        if(node == this._grid.endNode) return 0xcccccc;
        return 0xffffff;
    }

    /**
     * Handles the click event on the GridView. Finds the clicked on cell and toggles its walkable state.
     */
    private onGridClick(event:egret.TouchEvent):void
    {
        var xpos = Math.floor(event.stageX / this._cellSize);
        var ypos = Math.floor(event.stageY / this._cellSize);
        this._grid.setEndNode(xpos, ypos);

        xpos = Math.floor(this._player.x / this._cellSize);
        ypos = Math.floor(this._player.y / this._cellSize);
        this._grid.setStartNode(xpos, ypos);

        this.drawGrid();

        this.startTime = egret.getTimer();
        this.findPath();
        console.log("耗时:", egret.getTimer() - this.startTime);
    }

    private startTime = ;

    /**
     * Creates an instance of AStar and uses it to find a path.
     */
    private findPath():void
    {
        var aStar:astar.AStar = new astar.AStar();
        if(aStar.findPath(this._grid))
        {
            this._path = aStar.path;
            this._index = ;
            this.addEventListener(egret.Event.ENTER_FRAME, this.onEnterFrame, this);
        }
    }

    /**
     * Finds the next node on the path and eases to it.
     */
    private onEnterFrame(event:egret.Event):void
    {
        var targetX = this._path[this._index].x * this._cellSize +  this._cellSize / ;
        var targetY = this._path[this._index].y * this._cellSize + this._cellSize / ;
        var dx = targetX - this._player.x;
        var dy = targetY - this._player.y;
        var dist = Math.sqrt(dx * dx + dy * dy);
        if(dist < )
        {
            this._index++;
            if(this._index >= this._path.length)
            {
                this.removeEventListener(egret.Event.ENTER_FRAME, this.onEnterFrame, this);
            }
        }
        else
        {
            this._player.x += dx * .;
            this._player.y += dy * .;
        }
    }
}