游戏寻路A*算法

A*算法是一种启发式的BFS,目的就是找到到达目标位置的最短路径。启发式函数如下:

f(x) = g(x) + h(x)

g(x)是对出发点到达当前点距离的估约,h(x)是当前点到终点距离的估约。算法是一个广度优先搜索的过程,但是搜索时的可选集合是一个优先级队列,f(x)越小优先级越高。

 

算法过程描述

1。用起点初始优先级队列opened;

2。在opened中取最小f(x)的坐标节点,如果该点就是终点,则成功找到返回,否则,向该点的相邻方向寻找可行的下一个移动节点,计算每一个可行节点的f(x)保存,放入opened队列中,继续步骤2;

关于最短路径的求解还应该维护一个映射表,保存移动过程的上一个节点,之后再从终点往前遍历到起点便是整条路径了。

求单源最短路径的迪杰斯特拉算法其实就是当h(x)=0的A*算法。以下是算法的伪码(摘自维基百科

function A*(start,goal)
    closedset := the empty set    // The set of nodes already evaluated.
    openset := {start}    // The set of tentative nodes to be evaluated, initially containing the start node
    came_from := the empty map    // The map of navigated nodes.

    g_score[start] := 0    // Cost from start along best known path.
    // Estimated total cost from start to goal through y.
    f_score[start] := g_score[start] + heuristic_cost_estimate(start, goal)
     
    while openset is not empty
        current := the node in openset having the lowest f_score[] value
        if current = goal
            return reconstruct_path(came_from, goal)
         
        remove current from openset
        add current to closedset
        for each neighbor in neighbor_nodes(current)
            tentative_g_score := g_score[current] + dist_between(current,neighbor)
            tentative_f_score := tentative_g_score + heuristic_cost_estimate(neighbor, goal)
            if neighbor in closedset and tentative_f_score >= f_score[neighbor]
                    continue

            if neighbor not in openset or tentative_f_score < f_score[neighbor] 
                came_from[neighbor] := current
                g_score[neighbor] := tentative_g_score
                f_score[neighbor] := tentative_f_score
                if neighbor not in openset
                    add neighbor to openset

    return failure

 

详细设计实现

游戏中自动寻路的场景会被划分成网格,每一个网格可以是阻挡或者通路,在当前网格中可以向周围8个相邻方向移动(左,右,上,下,左上,左下,右上,右下)。运用A*算法从start寻路到end,启发式函数可以这样设计:

1。g(x)设计:初始化起点的g(start) = 0。假设当前位置是cur,下一个位置next若是cur从对角移动过来的(即左上,左下,右上,右下)则g(next) = g(cur) + 14,若是从水平或者垂直方向移动过来的,则g(next) = g(cur) + 10。常数14和10是这么得来的:勾股定理中,假设两直角边都是1,对角线则是1.414,各自放大10倍取整就是10和14;

2。h(x)设计:假设当前节点是(xcur,ycur),终点是(xend,yend),h(x) = abs(xcur – xend) + abs(ycur- yend);

 

优先级队列可以用最小堆来实现,但是搜索过程中可能出现这样的情况:新添加一个可用节点时,该节点已经在opened队列中了,且新节点有更小的f(x)值,这时候要更新队列中这个节点并重新调整堆。查找新入的节点是否已经在队列中了,单纯用最小堆实现时间复杂度是O(n),可以再加一个hash表,维护坐标点到最小堆中节点的映射,复杂度降为O(1)。代码实现如下:

 

#define TI(x, y) ((x)*H+(y))

struct OpenedNode{
	int _f, _g;
	int _x, _y;
	int _parent;
	OpenedNode(int f = -1, int g = -1, int x = -1, int y = -1, int parent = -1):_f(f),_g(g),_x(x),_y(y),_parent(parent) {}
	
};

template <size_t W, size_t H>
class OpenedHeap {
	OpenedNode _heap[W*H];
	int _set[W*H];
	int _sz;

	void move_top(int icur) {
		OpenedNode ON = _heap[icur];
		while (icur > 0) {
			int iparent = (icur-1) / 2;
			if (_heap[iparent]._f <= ON._f) break;

			_heap[icur]	   = _heap[iparent];

			// update
			_set[TI(_heap[icur]._x,_heap[icur]._y)] = icur;

			icur = iparent;
		}
		_heap[icur] = ON;
		_set[TI(_heap[icur]._x, _heap[icur]._y)] = icur;
	}

	void move_bottom(int icur) {
		OpenedNode ON = _heap[icur];
		while (true) {
			int ileft = icur * 2 + 1;
			if (ileft >= _sz) break;

			int iright = icur * 2 + 2;

			int ismaller = iright < _sz && _heap[iright]._f < _heap[ileft]._f? iright:ileft;

			if (_heap[ismaller]._f < ON._f) {
				_heap[icur] = _heap[ismaller];
				_set[TI(_heap[icur]._x, _heap[icur]._y)] = icur;
				icur = ismaller;
			}else break;
		}
		_heap[icur] = ON;
		_set[TI(_heap[icur]._x, _heap[icur]._y)] = icur;
	}

public:
	OpenedHeap():_sz(0) {
		memset(_set, -1, sizeof(_set));
	}


	void push(const OpenedNode &ON) {
		_heap[_sz] = ON;
		int icur = _sz++;

		move_top(icur);
	//	ensure();
	}

	void pop(OpenedNode &ret) {
		ret = _heap[0];
		_set[TI(_heap[0]._x,_heap[0]._y)] = -1;
		assert(_sz>0);
		_heap[0] = _heap[--_sz];
		if (_sz > 0)
			move_bottom(0);
//		ensure();
	}

	bool Get(int x, int y, OpenedNode &ret) {
		if (_set[TI(x,y)] >= 0) {
			ret = _heap[_set[TI(x,y)]];
			return true;
		}
		return false;
	}
	
	bool make_smaller(int x, int y, int f, int g, int parent) {
		int icur = _set[TI(x,y)];
		assert(_heap[icur]._x == x && _heap[icur]._y == y);
		if (icur < 0) return false;
		if (f == _heap[icur]._f) return true;
		bool top = false;
		if (f < _heap[icur]._f) top = true;
		_heap[icur]._f = f;
		_heap[icur]._g = g;
		_heap[icur]._parent = parent;

		if (top) {
			move_top(icur);
		}else {
			move_bottom(icur);
		}

		//ensure();
		return true;
	}

注意事项:

这也是我实现中犯过的错:

1。移动过程中不能从子节点回到直接父节点,这个是理所当然,所以实现时候在往8个方向移动时要屏蔽父节点。

2。已经在closed中的节点是有可能重新加入opened中的,所以在移动时得到一个新的节点时还要判断是不是比closed中这个节点更cheap(若closed中已经存在这个节点了)。

 

全部代码在此。可以用在游戏地图动态生成中实现的地图来测试A*寻路,下面是在一个35*100的地图中的自动寻路的效果(字符'-'代表路径)

image

posted @ 2013-12-22 16:22  persistentsnail  阅读(1081)  评论(1编辑  收藏  举报