AStar A* A星 算法TypeScript版本

最新推荐文章于 2024-10-18 12:51:39 发布
最新推荐文章于 2024-10-18 12:51:39 发布
阅读量633 收藏 3
点赞数
文章标签： javascript ViewUI
原文链接：http://www.cnblogs.com/gamedaybyday/p/7778995.html
版权

 

一 演示效果

 

 

二  参考教程

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

   http://download.csdn.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 = 0;
            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(0, node.x - 1);
                var endX = Math.min(this._grid.numCols - 1, node.x + 1);
                var startY = Math.max(0, node.y - 1);
                var endY = Math.min(this._grid.numRows - 1, node.y + 1);
                
                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 = 0; o < this._open.length; o++)
                {
                }
                this._closed.push(node);
                if(this._open.length == 0)
                {
                    console.log("AStar >> no path found");
                    return false
                }
                
                let openLen = this._open.length;
                for(let m=0;m<openLen;m++){
                    for(let n=m+1;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 = 0; i < this._open.length; i++)
            {
                if(this._open[i] == node)
                {
                    return true;
                }
            }
            return false;
        }
        
        //是否已检查
        private isClosed(node:Node):boolean
        {
            for(var i = 0; 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 - 2 * 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=0;i<numCols;i++){
                this._nodes[i] = [];
                for(let j:number=0;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 = 20;
    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(0, 0, 5);
        this._player.graphics.endFill();
        this._player.x = Math.random() * 600;
        this._player.y = Math.random() * 600;
        this.addChild(this._player);
    }

    
    /**
     * Creates a grid with a bunch of random unwalkable nodes.
     */
    private makeGrid():void
    {
        this._grid = new astar.Grid(30,30);
        for(var i = 0; i < 200; i++)
        {
            this._grid.setWalkable(Math.floor(Math.random() * 30),
                                Math.floor(Math.random() * 30),
                                false);
        }
        this.drawGrid();
    }
    
    /**
     * Draws the given grid, coloring each cell according to its state.
     */
    private drawGrid():void
    {
        this.graphics.clear();
        for(let i = 0; i < this._grid.numCols; i++)
        {
            for(let j = 0; 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(0,0,20,20);
                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 0;
        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 = 0;
    
    /**
     * 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 = 0;
            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 / 2;
        var targetY = this._path[this._index].y * this._cellSize + this._cellSize / 2;
        var dx = targetX - this._player.x;
        var dy = targetY - this._player.y;
        var dist = Math.sqrt(dx * dx + dy * dy);
        if(dist < 1)
        {
            this._index++;
            if(this._index >= this._path.length)
            {
                this.removeEventListener(egret.Event.ENTER_FRAME, this.onEnterFrame, this);
            }
        }
        else
        {
            this._player.x += dx * .5;
            this._player.y += dy * .5;
        }
    }
}

 

转载于:https://www.cnblogs.com/gamedaybyday/p/7778995.html

weixin_30595035
关注
typescript - A星自动寻路算法和Dijkstra寻路算法的实现.zip
06-29
字符串加密
ASTAR (A*)寻路基础学习，typescript
EddyLwei的博客
08-26 827
经典a*算法
TypeScript AST 查看器: 深入理解TS语法树的神器
最新发布
gitblog_01271的博客
10-18 256
TypeScript AST 查看器: 深入理解TS语法树的神器 ts-ast-viewer TypeScript AST viewer. 项目地址: https://gitcode.com/gh_mirrors/ts/ts-as...
smoothstep源码(TS版本)
06-27 220
/** * 返回0-1平滑阶梯函数的值 * @param a 变量a * @param b 变量b * @param c 变量c */ public static smoothstep( a: number, b: number, c: number ): number { let x = this.clamp( ( c - a ) / ( b - a ), 0, 1 ); ...
CocosCreator之A星寻路
Nick_Li_的博客
08-03 2157
源码地址： https://github.com/NickMonkeys/AStar
A*算法A星算法
08-16
1. **AStar代码**：这部分将包含A*算法的实现，可能是用C++编程语言编写的。C++是一种强大且高效的编程语言，适合处理复杂的数据结构和算法实现。代码可能会定义节点类，包含位置信息、父节点引用、`g(n)`和`h(n)`值...
unity简单实现AStar A*算法
09-18
Unity简单实现A*算法 一、功能概述 1.地图节点类 坐标值； 定义节点类型； 记录父节点； 计算F,G,H； 2.AStart类 寻路； 寻找路径点； openList； closeList； 建立链表关系； 按照F值排序；
A*算法(Astar算法/A星算法)C++模板函数实现.zip
01-28
Astar.hpp //这是A*算法的模板函数实现 (还附送个快排算法 testMain_eightDigital.cpp //这是A*算法求解八数码问题的测试用例 testMain_maze.cpp //这是A*算法走迷宫的测试用例 mazeMap.txt //这是A*算法走迷宫...
AStar A*算法
03-18
**AStar（A*）算法**是一种广泛应用的路径搜索算法，尤其在游戏开发、地图导航、机器人避障等领域中有着重要地位。A*算法结合了最佳优先搜索（BFS）和Dijkstra算法的优点，通过引入启发式信息来指导搜索过程，以更...
tsgraph:TypeScript中的A *搜索算法实现
03-07
tsgraph tsgraph是TypeScript中的Star搜索算法实现。
二维A*算法路径规划matlab代码
11-16
以复杂岛屿地图为例，做了二维A*路径规划。代码为MATLAB代码，解压后可以直接运行。文件夹内AstarCSDN为主文件，TrunToGridMap为地图转栅格文件，child_nodes_cal为计算子节点的函数，1234d.jpg为地图图片。
A星寻路算法及拆解demo
Tony-Chen的博客
02-26 589
关于自动寻路，在游戏中还是经常会遇到的。如角色如何代价最小(距离少，时间快，方式支持)移动到某个位置。本篇记录下A*寻路的流程与优化。为了做一个可以方便展示在web的demo，更好拆解寻路的步骤，所以本篇用了cocos creater + ts实现。A星算法是dijkstra的升级版()，也是属于广度搜索遍历，不同于dijkstra，A星不需要遍历图中所有的节点。而是尽可能的去靠近终点。可以做个想象：地图比作一个挂起来的迷宫，起点在上方，终点在下方，从上方注入水，水会随着重力尽可能向下方(终点)流去。
A*算法 源代码
qq_19399235的博客
02-13 994
#include #include #include #define MaxLength 100 //用于优先队列（Open表）的数组 #define Height 15 //地图高度 #define Width 20 //地图宽度 #define Reachable 0 //可以到达的结点 #define Bar 1
A* 算法
BORN TO WIN
09-14 587
简单描述一下A*原理： 两个集合： OpenList: 可到达的格子 CloseList: 已到达的格子 一个公式： F = G + H 解释一下：F、G、H是格子的3个属性 G: 从起点走到当前格子的成本，也就是已经花费了多少步。 H: 在不考虑障碍的情况下，从当前格子走到目标格子的距离，也就是距离目标还有多远。 F: G 和 H的综合评估，也就是从起点到达当前格子，再从当前格子到达目标格子的总步数。 第1步，先把起点放入OpenList。 OpenList： Gr...
A*寻路TS实现
weakenCoder的博客
08-05 1302
const {ccclass, property} = cc._decorator; @ccclass export default class Helloworld extends cc.Component { @property(cc.Prefab) blockPb: cc.Prefab = null; @property(cc.Node) DITU: cc.Node = null; @p...
A*寻路算法
a185368204的专栏
07-07 415
A*寻路算法 A*寻路算是游戏开发中很常见的一种寻路算法，网络上相关的介绍也非常多，这次从其他寻路算法谈起，来看一看A星算法是如何诞生的，本文所有寻路算法使用TypeScript实现 算法默认权重不为负数 广度优先搜索 广度优先搜索，就如同洪水一样，从搜索起点不断往外扩张 搜索实现 构建一个搜索队列searchList，列表中的节点就是等待搜索的节点，初始化时将起点加入到列表中; 构建一个...
A星算法（A*/A Star）
成君的博客
05-26 3867
A星算法的前世今生 : 一、广度优先搜索（Breadth-first search (BFS)） BFS是一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。它并不考虑结果的可能位址，彻底地搜索整张图，直到找到结果为止。 算法逻辑: * 初始化open_list和close_list； * 将起点加入open_list中； * 如果open_list不为空，则从open_list中选取第一个节点n： ...
（板子）A* astar算法，AcWing第k短路+八数码 带注释
weixin_62848089的博客
10-12 783
N），MM 条边的有向图，求从起点 SS 到终点 TT 的第 KK 短路的长度，路径允许重复经过点或边。接下来 MM 行，每行包含三个整数 A,BA,B 和 LL，表示点 AA 与点 BB 之间存在有向边，且边长为 LL。最后一行包含三个整数 S,TS,T 和 KK，分别表示起点 SS，终点 TT 和第 KK 短路。输出占一行，包含一个整数，表示第 KK 短路的长度，如果第 KK 短路不存在，则输出 −1−1。现在，给你一个初始网格，请你通过最少的移动次数，得到正确排列。如果不存在解决方案，则输出。
A*寻路算法项目Pro最新版本v4.2.18发布
A星寻路算法（A* Algorithm），通常被称为A* 寻路算法或A星算法，是计算机科学领域中一种在图形平面上，有多个节点的路径，求出最低通过成本的路径的算法。它将传统的A算法与路径最佳化的特点相结合。A* 寻路算法在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值