erlang之A*寻路

最新推荐文章于 2020-03-30 11:45:24 发布
最新推荐文章于 2020-03-30 11:45:24 发布
阅读量421 收藏
点赞数
分类专栏： erlang技术 文章标签： a*寻路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42973473/article/details/82862896
版权

1. search.erl

%%%===================模块描述(开始)=====================
%% 
%%%===================模块描述(结束)=====================
-module(search).
%%%=======================STATEMENT====================
-time("2018/8/24 10:45").
%%%=======================EXPORT=======================
-export([search/5, printf/6]).
%%%=======================INCLUDE======================
-include("search.hrl").
%%%=======================RECORD=======================
%%%=======================DEFINE=======================
-define(DEBUG, false).
%%%=================EXPORTED FUNCTIONS=================
%% ----------------------------------------------------
%% @doc
%%      
%% @end
%% ----------------------------------------------------
search(X, Y, TargetX1, TargetY1, {M, F, A}) ->
    Obstacles = M:F(A),
    if
        ?DEBUG ->
            {ok, IO} = file:open("Obstacles.log", write),
            io:format(IO, "~w", [Obstacles]),
            file:close(IO);
        true ->
            ok
    end,
    ObEts = ets:new(?MODULE, []),
    [ets:insert(ObEts, {P, 1}) || P <- Obstacles],
    case search_lib:check_target(TargetX1, TargetY1, ?X_MIN, ?Y_MIN, ?X_MAX, ?Y_MAX, ObEts) of
        none ->
            "all_obstacles";
        {TargetX, TargetY} ->
            Start = search_lib:init_point(X, Y, -1, -1),%%初始化开始坐标点
            case search_lib:sub_points(X, Y, ?X_MIN, ?X_MAX, ?Y_MIN, ?Y_MAX, ObEts) of
                [] ->
                    "no_path";
                Subs ->
                    Open = ets:new(?MODULE, [{keypos, #point.point}]),
                    [begin
                         Point = search_lib:init_point(PointX, PointY, X, Y),
                         H = search_h:get_h(PointX, PointY, TargetX, TargetY),
                         ets:insert(Open, Point#point{f = H + Weight, h = H, g = Weight})
                     end || {{PointX, PointY}, Weight} <- Subs],
                    Close = ets:new(?MODULE, [{keypos, #point.point}]),
                    ets:insert(Close, Start),
                    search_(TargetX, TargetY, Open, Close, ObEts)
            end
    end.


%%%===================LOCAL FUNCTIONS==================
%% ----------------------------------------------------
%% @doc
%%      
%% @end
%% ----------------------------------------------------
search_(TargetX, TargetY, Open, Close, ObEts) ->
    H = search_lib:get_min(Open),
    {HX, HY} = H#point.point,
    SubPoint = search_lib:sub_points(HX, HY, 0, ?X_MAX, 0, ?Y_MAX, ObEts),%%获得所有能用的子节点
    case check(TargetX, TargetY, H, SubPoint, Open, Close) of
        {'end', Point} ->
            Path = back(Point, Close, []),
            if
                ?DEBUG ->
                    printf(TargetX, TargetY, Path, ObEts, 0, ?Y_MAX);
                true ->
                    Path
            end;
        ok ->
            case ets:info(Open, size) of
                N when N > 0 ->
                    ets:insert(Close, H),
                    search_(TargetX, TargetY, Open, Close, ObEts);
                _ ->
                    Path = back(H, Close, []),
                    if
                        ?DEBUG ->
                            printf(TargetX, TargetY, Path, ObEts, 0, ?Y_MAX);
                        true ->
                            Path
                    end
            end
    end.

back(Point, Close, Result) ->
    if
        Point#point.parent =:= {-1, -1} ->
            Result;
        true ->
            [Parent] = ets:lookup(Close, Point#point.parent),
            back(Parent, Close, [Point#point.point | Result])
    end.

check(_TargetX, _TargetY, _Parent, [], _Open, _Close) ->
    ok;
check(TargetX, TargetY, Parent, [{{TargetX, TargetY}, _Weight} | _SubPoints], _Open, _Close) ->
    {'end', Parent};
check(TargetX, TargetY, Parent, [{{X, Y}, Weight} | SubPoints], Open, Close) ->
    case ets:lookup(Close, {X, Y}) of
        [] ->
            {ParentX, ParentY} = Parent#point.point,
            case ets:lookup(Open, {X, Y}) of
                [] ->%%不在,计算GHF,存入开启列表中
                    Point = search_lib:init_point(X, Y, ParentX, ParentY),
                    G = Parent#point.f + Weight,
                    H = search_h:get_h(X, Y, TargetX, TargetY),
                    if
                        H == 0 ->
                            {'end', Parent};
                        true ->
                            ets:insert(Open, Point#point{f = H + G, h = H, g = G}),
                            check(TargetX, TargetY, Parent, SubPoints, Open, Close)
                    end;
                [OldPoint] ->%%在开启列表中,检查以当前节点为父节点,F是否更优
                    G = Parent#point.f + Weight,
                    H = search_h:get_h(X, Y, TargetX, TargetY),
                    if
                        H == 0 ->
                            {'end', Parent};
                        H < OldPoint#point.h ->
                            ets:insert(Open, OldPoint#point{f = H + G, h = H, g = G, parent = {ParentX, ParentY}}),
                            check(TargetX, TargetY, Parent, SubPoints, Open, Close);
                        true ->
                            check(TargetX, TargetY, Parent, SubPoints, Open, Close)
                    end
            end;
        _ ->%%关闭列表中忽略
            check(TargetX, TargetY, Parent, SubPoints, Open, Close)
    end.


printf(TX, TY, Path, ObEts, X, Y) when Y =:= -1 ->
    if
        X =:= 0 ->
            io:format(" * ", []);
        X < 10 ->
            io:format(" ~p ", [X - 1]);
        X < 100 ->
            io:format(" ~p", [X - 1]);
        true ->
            io:format("~p", [X - 1])
    end,
    if
        X > ?X_MAX ->
            io:format("~n", []);
        true ->
            printf(TX, TY, Path, ObEts, X + 1, Y)
    end;
printf(_TX, _TY, _Path, _Obstacles, _X, Y) when Y < 0 ->
    ok;
printf(TX, TY, Path, ObEts, X, Y) when X > ?X_MAX ->
    io:format("~n", []),
    if
        Y =:= 0 ->
            ok;
        Y < 10 ->
            io:format(" ~p ", [Y - 1]);
        Y < 100 ->
            io:format(" ~p", [Y - 1])
    end,
    printf(TX, TY, Path, ObEts, 0, Y - 1);
printf(TX, TY, Path, ObEts, X, Y) ->
    if
        Y =:= ?Y_MAX andalso X =:= 0 ->
            io:format(" ~p", [?Y_MAX]);
        true ->
            ok
    end,
    if
        TX =:= X andalso TY =:= Y ->
            io:format("$=$", []);
        true ->
            case ets:lookup(ObEts, {X, Y}) of
                [_] ->
                    io:format(" / ", []);
                _ ->
                    case lists:member({X, Y}, Path) of
                        true ->
                            io:format(" * ", []);
                        _ ->
                            io:format(" - ", [])
                    end
            end
    end,
    printf(TX, TY, Path, ObEts, X + 1, Y).


io(Key, Content) ->
    if
        ?DEBUG ->
            io:format("~p~n", [{Key, Content}]),
            io:get_line("next");
        true ->
            ok
    end.

2. search_h.erl

%%%===================模块描述(开始)=====================
%% 
%%%===================模块描述(结束)=====================
-module(search_h).
%%%=======================STATEMENT====================
-time("2018/8/24 10:54").
%%%=======================EXPORT=======================
-export([get_h/4]).
%%%=======================INCLUDE======================
%%%=======================RECORD=======================
%%%=======================DEFINE=======================
%%%=================EXPORTED FUNCTIONS=================
%% ----------------------------------------------------
%% @doc
%%      计算h值(扩大一百倍除去小数返回)
%% @end
%% ----------------------------------------------------
get_h(X, Y, X, TargetY) ->
    abs(Y - TargetY);
get_h(X, Y, TargetX, Y) ->
    abs(X - TargetX);
get_h(X, Y, TargetX, TargetY) ->
    XV = abs(X - TargetX),
    YV = abs(Y - TargetY),
    math:sqrt(XV * XV + YV * YV)*1.5.
%%    trunc(math:sqrt(XV * XV + YV * YV)*100).
%%%===================LOCAL FUNCTIONS==================
%% ----------------------------------------------------
%% @doc
%%      
%% @end
%% ----------------------------------------------------

3. search_lib.erl

%%%===================模块描述(开始)=====================
%% 
%%%===================模块描述(结束)=====================
-module(search_lib).
%%%=======================STATEMENT====================
-time("2018/8/24 10:45").
%%%=======================EXPORT=======================
-export([sub_points/7, init_point/4, init_obstacles/1, obstacles_list/1, check_target/7,
         read_obstacles/1, get_min/1]).
%%%=======================INCLUDE======================
-include("search.hrl").
%%%=======================RECORD=======================
%%%=======================DEFINE=======================
-define(LEFT, 1).
-define(TOP, 2).
-define(RIGHT, 3).
-define(BOTTOM, 4).
-define(MAX_LOOP, 100).
%%%=================EXPORTED FUNCTIONS=================
%% ----------------------------------------------------
%% @doc
%%      获得一个节点的所有可用子节点及其权重
%%      ==>[{{X,Y},Weight},....]
%% @end
%% ----------------------------------------------------
sub_points(X, Y, XMin, XMax, YMin, YMax, ObEts) ->
    X1 = max(XMin, X - 1),
    X2 = min(XMax, X + 1),
    Y1 = max(YMin, Y - 1),
    Y2 = min(YMax, Y + 1),
    lists:keydelete({X, Y}, 1, sub_points_(X + Y, X1, X2, Y1, Y1, Y2, ObEts, [])).

sub_points_(_Sum, X1, X2, _CurrntY, _Y, _YMax, _Obstacles, Result) when X1 > X2 ->
    Result;
sub_points_(Sum, X1, X2, CurrntY, Y, YMax, ObEts, Result) when CurrntY > YMax ->
    sub_points_(Sum, X1 + 1, X2, Y, Y, YMax, ObEts, Result);
sub_points_(Sum, X1, X2, CurrntY, Y, YMax, ObEts, Result) ->
    case ets:lookup(ObEts, {X1, CurrntY}) of
        [] ->
            Weight = if
                         abs(Sum - (X1 + CurrntY)) =:= 1 ->
                             1.0;
                         true ->
                             1.4142135623730951
                     end,
            sub_points_(Sum, X1, X2, CurrntY + 1, Y, YMax, ObEts, [{{X1, CurrntY}, Weight} | Result]);
        _ ->
            sub_points_(Sum, X1, X2, CurrntY + 1, Y, YMax, ObEts, Result)

    end.

%%初始化一个坐标点
init_point(X, Y, ParentX, ParentY) ->
    #point{f      = 0,
           h      = 0,
           g      = 0,
           point  = {X, Y},
           parent = {ParentX, ParentY}
    }.

%%生成障碍物
init_obstacles(Ratio) ->
    init_obstacles(Ratio, 0, ?Y_MAX, []).
init_obstacles(_Ratio, _X, Y, Result) when Y < 0 ->
    Result;
init_obstacles(Ratio, X, Y, Result) when X > ?X_MAX ->
    init_obstacles(Ratio, 0, Y - 1, Result);
init_obstacles(Ratio, X, Y, Result) ->
    case z_lib:random(1, 100) < Ratio of
        true ->
            init_obstacles(Ratio, X + 1, Y, [{X, Y} | Result]);
        _ ->
            init_obstacles(Ratio, X + 1, Y, Result)
    end.
%%障碍物列表
obstacles_list(List) ->
    List.
read_obstacles(FileName) ->
    {ok, [Obs]} = file:consult(FileName),
    Obs.


%%检查目标点是否是障碍物
%%如果不是直接返回目标点,如果是循环查找目标点周围不是障碍物的点
%%寻找指定次数之后全是障碍物,返回none
check_target(X, Y, XMin, YMin, XMax, YMax, ObEts) ->
    case ets:lookup(ObEts, {X, Y}) of
        [] ->
            {X, Y};
        _ ->
            check_target_(0, X - 1, Y - 1, XMin, YMin, XMax, YMax, ObEts, ?LEFT, 1, 1)
    end.
check_target_(LoopTimes, _X, _Y, _XMin, _YMin, _XMax, _YMax, _Obstacles, _Direction, _Num, _Circle) when LoopTimes > ?MAX_LOOP ->%%最大循环查找次数
    none;
check_target_(LoopTimes, X, Y, XMin, YMin, XMax, YMax, Obstacles, Direction, _Num, Circle) when Direction > ?BOTTOM ->%%换圈层
    check_target_(LoopTimes + 1, X - 1, Y - 1, XMin, YMin, XMax, YMax, Obstacles, 1, 0, Circle + 1);
check_target_(LoopTimes, X, Y, XMin, YMin, XMax, YMax, ObEts, Direction, Num, Circle) ->
    case X < XMin orelse X > XMax orelse Y < YMin orelse Y > YMax orelse ets:lookup(ObEts, {X, Y}) =/= [] of
        true ->
            if
                Num >= Circle + 2 ->
                    check_target_(LoopTimes + 1, X, Y, XMin, YMin, XMax, YMax, ObEts, Direction + 1, 1, Circle);
                Direction =:= ?LEFT ->
                    check_target_(LoopTimes + 1, X, Y + 1, XMin, YMin, XMax, YMax, ObEts, Direction, Num + 1, Circle);
                Direction =:= ?TOP ->
                    check_target_(LoopTimes + 1, X + 1, Y, XMin, YMin, XMax, YMax, ObEts, Direction, Num + 1, Circle);
                Direction =:= ?RIGHT ->
                    check_target_(LoopTimes + 1, X, Y - 1, XMin, YMin, XMax, YMax, ObEts, Direction, Num + 1, Circle);
                true ->
                    check_target_(LoopTimes + 1, X - 1, Y, XMin, YMin, XMax, YMax, ObEts, Direction, Num + 1, Circle)
            end;
        _ ->
            {X, Y}
    end.

get_min(Ets) ->
    case ets:first(Ets) of
        '$end_of_table' ->
            none;
        F ->
            K = get_min(Ets, F, hd(ets:lookup(Ets,F))),
            ets:delete(Ets, K#point.point),
            K
    end.

get_min(_Ets, '$end_of_table', Point) ->
    Point;
get_min(Ets, Key, Point) ->
    P = ets:lookup(Ets, Key),
    if
        P#point.f < Point#point.f ->
            get_min(Ets, ets:next(Ets, Key), P);
        true ->
            get_min(Ets, ets:next(Ets, Key), Point)
    end.


%%%===================LOCAL FUNCTIONS==================
%% ----------------------------------------------------
%% @doc
%%      
%% @end
%% ----------------------------------------------------

4. search_h.hrl

%%%-------------------------------------------------------------------
%%% @author Administrator
%%% @copyright (C) 2018, <COMPANY>
%%% @doc
%%%
%%% @end
%%% Created : 28. 八月 2018 14:15
%%%-------------------------------------------------------------------
-author("Administrator").
-record(point, {f, h, g, point, parent}).
%%坐标系统的最大值最小值
-define(X_MAX, 60).
-define(Y_MAX, 50).
-define(X_MIN, 0).
-define(Y_MIN, 0).
牧码丶天涯
关注
专栏目录
erlang面试经（2）
小老鼠啊的博客
12-29 2682
面试经（2）一、OTP相关二、定时器三、运算符四、算法五、Erlang有哪些运算符六、请写出Erlang条件表达式、循环七、如何匹配binary（二进制位也就是字节，默认的话是比特位）从第三字节开始的八、请举例替换二进制字符串中的指定字符串九、怎么使用Erlang语言实现Key和Value的存储十、跨进程通信、跨节点（服务器）通信方式有哪些十一、请简述一下服务器上线出问题处理的流程十二、有哪些调试...
erlang进程占用内存过多的查找问题过程
pyf725324的专栏
11-20 2570
最近开发一个
Erlang B星寻路算法源代码 B*寻路算法源代码
06-22
Erlang B星寻路算法源代码 B*寻路算法源代码, 由C++改写而来。效率是A星算法的几十倍到上百倍。做为服务端怪物寻路的最佳选择。
erlang的a*寻路之双A*寻路
qq_42973473的博客
03-30 378
1. 先说下环境: a.我们是slg大地图寻路,地图尺寸是10001000. b.2D地图,没有高度的概念. c.忽略人物模型大小,默认只要路径联通即能通过. d.只做静态障碍的寻路(比如资源点,山脉河流等),不做动态障碍的寻路(玩家主城,怪物等) 2. 在说下大致思路:(请先看图) a.将地图切分成5050等大小的400个大格子(绿色的方格子,黑色的线条是山脉,河流等等障碍物) b.每个大格...
erlang实现A星算法
gxquickly的专栏
01-07 1582
A星算法是寻路的经典算法，在很多游戏中有使用，性能关键在于启发函数的设计。 函数式语言erlang实现一些算法上还是相当绕，有一些无可避免的地方需要用一些非典型的语法实现（变量不可变、无循环语法、无法在函数中return等），实现了一个基础的A星算法，启发式函数使用对角线估价法，先按对角线走，一直走到与终点水平或垂直平行后，再笔直的走。 随便构造一个地图文件来进行测试，用erlang的stat
erlang角色寻路bresenham算法
03-11
假设场景网格如下 数字代表的是坐标 11代表的是x1,y1 46代表的是 x4,y6 11, 12, 13, 14, 15, 16, 17, 18, 19 21, 22, 23, 24, 25, 26, 27, 28, 29 33, 32, 33, 34, 35, 36, 37, 38, 39 41, 42, 43, 44, 45, 46, 47, 48, 49 51, 52, 53, 54, 55, 56, 57, 58, 59 61, 62, 63, 64, 55, 66, 67, 68, 69 71, 72, 73, 74, 75, 76, 77, 78, 79 81, 82, 83, 84, 55, 86, 87, 88, 89 91, 92, 93, 94, 55, 96, 97, 98, 99 那么角色的位置是11 寻路到96呢 11, 12, 13, 14, 15, 16, 17, 18, 19 21, 22, 23, 24, 25, 26, 27, 28, 29 33, 32, 33, 34, 35, 36, 37, 38, 39 41, 42, 43, 44, 45, 46, 47, 48, 49 51, 52, 53, 54, 55, 56, 57, 58, 59 61, 62, 63, 64, 55, 66, 67, 68, 69 71, 72, 73, 74, 75, 76, 77, 78, 79 81, 82, 83, 84, 55, 86, 87, 88, 89 91, 92, 93, 94, 55, 96, 97, 98, 99 这是我们要做的寻路网格，bresenham算法大致先求一轴向，在根据路径长短加令一轴。直接看代码吧erlang版
Erlang 写算法
yangchen521的专栏
04-24 889
看了两天Erlang，先拿微分进化算法练练手。
erl-heaps:为A *图形探路者按值删除O（log n）的Erlang优先堆
05-03
优先级堆的Erlang实现，通过值和其他一些对A *寻路算法非常有用的操作增强了O（log n）删除。 堆上的所有操作花费O（log n）时间： is_empty add take_min （删除并返回具有最小prority的元素） contains_value...
AStar 算法（erlang版本）
卧龙小学堂
01-07 992
A* 算法的erlang实现，外部使用需要提供判断坐标是否可走的函数，下面的代码在get_neighbour_coord函数里面使用到了map:is_movable_coord 函数，需要自己去实现并替换。以下是源码。 %%=========================astar.erl===================================== -module(
erlang-Astart算法
linvim的专栏
07-02 364
[code="java"] %%%------------------------------------------------------------------- %%% Module : astar_trace %%% Author : %%% Description : A星寻路算法 %%%-----------------------------------------...
A*寻路算法 源码
12-12
没积分了，下不了资源，只求一分，A*寻路算法 源码 c#
A星和B星寻路算法
03-29
用XNA4.0平台上写得A*和B*算法，其中B*算法有BUG的！由于时间关系没修复，但解决一般简单的路径是没问题的。只提供参考了解B*算法用。具体思路解释看代码注释。（ctrl + a进行A星算法，ctrl + b进行B星算法）
关于游戏中服务端erlang寻路---AStar+直线
好久不见
07-11 713
游戏介绍：一款可多人同屏的SLG, 每个玩家带自己的队伍在地图上寻路，确保数据丝毫不差，玩家看到的画面都是一致的~ 要求：同屏人数要求 20人，场景寻路单元20*5 + 怪物数量~~单场景极限150个单位 思路：1、地图导成0~1文件，0不可走、1可走 2、起点----终点，计算直线是否可走，是：走直线；否：步奏3 3、精度设置5~8（自行决定）...
项目记录07--客unity,服erlang--AStarPathing 寻路
u010665359的专栏
12-06 1400
AStarPathing:的2D使用：使用Grid Graph 注意：因为是2D所以Rotation一栏X:90   Collision testing的Mask选择碰撞的Layer ;Heigth Testing隐藏。  UGUI里面的物体都要叫上碰撞器，移动时候限制Z
Erlang：一个通用的网络服务器
hideto
09-24 201
原文: [url=http://20bits.com/2008/06/16/erlang-a-generalized-tcp-server/]Erlang: A Generalized TCP Server[/url] 前面几篇文章里谈到了Erlang的[url=http://20bits.com/2008/05/02/network-programming-in-erlang/]gen_t...
erlang下A*算法的效率优化过程
pyf725324的专栏
11-25 915
近期在做一个系统时发现项目中用的A*算法效率太差了，具体要时间上的话就是一个100路径点的寻路要花上大概50ms左右，在需要大量寻路的时候会非常卡。 1、首先分析A*算法的过程，摘自百度百科http://baike.baidu.com/view/7850.htm?fr=aladdin while(OPEN!=NULL) { 从OPEN表中取估价值f(n)最小的节点n;
AStar A* 算法的Erlang实现
Rolong的博客
04-24 2089
%% @author rolong@vip.qq.com %% 本代码来自 瑞仙的Erlang开发博客 %% http://blog.csdn.net/zhongruixian -module(astar1). -export([ find_path/2 ,test/2 ]). -record(state, { open
A*（AStar）或者也叫A星算法的寻路问题
Mage的专栏
11-03 1821
最近在学作游戏，需要了解一种很好很强大的，也很实用的地图有障碍物时寻找最隹路径的方法。 我发现这个方法不是只能用在游戏中，觉得机器人在室内或者室外自行移动，也完全适用这种算法。 下边开始学习： 在学习之前，要先了解一下A*算法中的专用术语： 1.节点：在基于区块的世界中这实际是一个区块。但，A*中没有使用区块（tile）、单元（cell）、点(potint)，而是使用了术语节点（node）
erlang学习笔记
Memory
05-29 645
erlang 随手记 erlang进程数量 (a@localhost)12&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;erlang:length(erlang:processes()). 42 (a@localhost)13&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; erlang内存使用情况 (a@localhost)11&amp;amp;amp;am
Erlang与OTP实战指南
"Erlang and OTP in Action 是一本关于Erlang编程语言及其 OTP (Open Telecom Platform) 应用框架的实战指南。本书通过实际案例深入浅出地介绍了Erlang的基础知识以及如何利用OTP构建高效、可靠的分布式系统。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值