실질적인 길 계획하기

게임 인공지능
GameAI

실질적인 길 계획하기
By Changhoon Park
http://wawworld.me
Last Update : 2011. 08. 28

11년 10월 13일 목요일

2

실질적인 NavGraph 구축 가시점
길 계획하기 Raven의 NavGraph 확장 지형
경로 계획자 클래스 NavMesh
노드경로/에지경로
난처한 상황 By Changhoon Park
http://wawworld.me


3

http://wawworld.me


4

http://wawworld.me


5

실질적인 NavGraph 구축 성긴 그래프
길 계획하기 Raven의 NavGraph 밀집 그래프
경로 계획자 클래스 아이템 추가
노드경로/에지경로 공간 분할
http://wawworld.me


6

http://wawworld.me


7

http://wawworld.me


8

http://wawworld.me


template <class extra_info = void*>
class NavGraphNode : public GraphNode
{
protected:
Vector2D m_vPosition;
extra_info m_ExtraInfo;
public:
//ctors
NavGraphNode():m_ExtraInfo(extra_info()){}
NavGraphNode(int idx,Vector2D pos):GraphNode(idx),
m_vPosition(pos), m_ExtraInfo(extra_info()) {}
virtual ~NavGraphNode(){}
Vector2D Pos()const;
void SetPos(Vector2D NewPosition);
extra_info ExtraInfo()const;
void SetExtraInfo(extra_info info);
};

9

http://wawworld.me


class Raven_PathPlanner
{
private:
enum {no_closest_node_found = -1};
private:
Raven_Bot* m_pOwner;
const Raven_Map::NavGraph& m_NavGraph;
Vector2D m_vDestinationPos;
int GetClosestNodeToPosition(Vector2D pos)const;
public:
Raven_PathPlanner(Raven_Bot* owner);
bool CreatePathToPosition(Vector2D TargetPos, std::list<Vector2D>& path);
bool CreatePathToItem(unsigned int ItemType, std::list<Vector2D>& path);
};

10

실질적인 NavGraph 구축 특정 위치까지의 경로
길 계획하기 Raven의 NavGraph 어떤 아이템 타입까지의 경로
경로 계획차 클래스
http://wawworld.me


11

경로 계획자 클래스
http://wawworld.me


bool Raven_PathPlanner::CreatePathToPosition(Vector2D TargetPos,std::list<Vector2D>& path)
{
m_vDestinationPos = TargetPos;

if (!m_pOwner()->GetWorld()->isPathObstructed(m_pOwner->Pos(), TargetPos,
m_pOwner->BRadius()))
{
path.push_back(TargetPos);
return true;
}

int ClosestNodeToBot = GetClosestNodeToPosition(m_pOwner->Pos());
if (ClosestNodeToBot == no_closest_node_found) {
return false;
}

12

http://wawworld.me


int ClosestNodeToTarget = GetClosestNodeToPosition(TargetPos);
if (ClosestNodeToTarget == no_closest_node_found)
{
return false;
}

typedef Graph_SearchAStar< Raven_Map::NavGraph, Heuristic_Euclid> AStar;
AStar search(m_NavGraph, ClosestNodeToBot, ClosestNodeToTarget);
std::list<int> PathOfNodeIndices = search.GetPathToTarget();
if (!PathOfNodeIndices.empty()) {
ConvertIndicesToVectors(PathOfNodeIndices, path);
path.push_back(TargetPos);
return true;
} else {
return false;
}
}

13

http://wawworld.me


14

http://wawworld.me


template <class graph_type, class termination_condition>
class Graph_SearchDijkstra
{
/* OMITTED */
};
========================================================================
static bool isSatisfied(const graph_type& G, int target, int CurrentNodeIdx);
========================================================================
if (NextClosestNode == m_iTarget) return; //if the target has been found exit
========================================================================

//if the target has been found exit
if (termination_condition::isSatisfied(m_Graph, m_iTarget, NextClosestNode))
{
m_iTarget = NextClosestNode;
return;
}

15

http://wawworld.me


template <class trigger_type>
class FindActiveTrigger
{
public:
template <class graph_type>
static bool isSatisfied(const graph_type& G, int target, int CurrentNodeIdx)
{
bool bSatisfied = false;
const graph_type::NodeType& node = G.GetNode(CurrentNodeIdx);
if ((node.ExtraInfo() != NULL) && node.ExtraInfo()->isActive() &&
(node.ExtraInfo()->EntityType() == target) )
{
bSatisfied = true;
}
return bSatisfied;
}
};

16

http://wawworld.me


typedef FindActiveTrigger<Trigger<Raven_Bot> > term_con;
typedef Graph_SearchDijkstra_TS<RavenMap::NavGraph, term_con> SearchDij;

//instantiate the search
SearchDij dij( G, // the graph
6, // the source node
type_health); // the item type we are searching for
//grab the path
std::list<int> path = dij.GetPathToTarget();

17

http://wawworld.me


18

실질적인 NavGraph 구축
길 계획하기 Raven의 NavGraph
http://wawworld.me


class NavGraphEdge : public GraphEdge
{
public:
//enumerate some behavior flags
enum BehaviorType
{
normal = 1 << 0,
tippy_toe = 1 << 1,
swim = 1 << 2,
crawl = 1 << 3,
creep = 1 << 4
};
protected:
BehaviorType m_iBehavior; //the behavior associated with traversing this edge

/* EXTRANEOUS DETAIL OMITTED */
};

19

실질적인 NavGraph 구축 주석이 달린 에지
길 계획하기 Raven의 NavGraph 경로 계획자 수정
경로 계획자 클래스 경로 부드럽게 하기
노드경로/에지경로 CPU오버헤드 줄이기
http://wawworld.me


class PathEdge
{
private:
//positions of the source and destination nodes this edge connects
Vector2D m_vSource;
Vector2D m_vDestination;
int m_iBehavior; //the behavior associated with traversing this edge
public:
PathEdge(Vector2D Source, Vector2D Destination, int Behavior)
: m_vSource(Source), m_vDestination(Destination), m_iBehavior(Behavior) {}
Vector2D Destination()const;
void SetDestination(Vector2D NewDest);
Vector2D Source()const;
void SetSource(Vector2D NewSource);
int Behavior()const;
};

20

http://wawworld.me


bool Raven_PathPlanner::CreatePathToPosition(Vector2D TargetPos, std::list<PathEdge>& path)
{

if (!m_pOwner()->GetWorld()->isPathObstructed(m_pOwner->Pos(), TargetPos, m_pOwner->BRadius())) {
path.push_back(PathEdge(m_pOwner->Pos(), TargetPos, NavGraphEdge::normal));
return true;
}

//no path possible
return false;
}

int ClosestNodeToTarget = GetClosestNodeToPosition(TargetPos);
if (ClosestNodeToTarget == no_closest_node_found) {
//no path possible
return false;
}

21

http://wawworld.me


//create an instance of the A* search class.
typedef Graph_SearchAStar<Raven_Map::NavGraph, Heuristic_Euclid> AStar;
AStar search(m_NavGraph, ClosestNodeToBot, ClosestNodeToTarget);
path = search.GetPathAsPathEdges(); //grab the path as a list of PathEdges

if (!path.empty()) {
path.push_front( PathEdge(m_pOwner->Pos(),
path.front().GetSource(), NavGraphEdge::normal));
path.push_back(PathEdge(path.back().GetDestination(),
TargetPos, NavGraphEdge::normal));
return true;
} else {
return false; //no path found by the search
}
}

22

http://wawworld.me


if (Bot.PathPlanner.CreatePathToPosition(destination, path))
{
PathEdge next = GetNextEdgeFromPath(path)
switch(next.Behavior)
{
case behavior_stealth:
set stealth mode
break
case behavior_swim
set swim mode
break
etc
}
Bot.MoveTo(NavGraph.GetNodePosition(next.To))
}

23

http://wawworld.me


24

http://wawworld.me


25

http://wawworld.me


26

http://wawworld.me


27

http://wawworld.me


void Raven_PathPlanner::SmoothPathEdgesQuick(std::list<PathEdge>& path)
{
//create a couple of iterators and point them at the front of the path
std::list<PathEdge>::iterator e1(path.begin()), e2(path.begin());
++e2; //increment e2 so it points to the edge following e1.
while (e2 != path.end())
{
//check for obstruction, adjust and remove the edges accordingly
if ( m_pOwner->canWalkBetween(e1->Source(), e2->Destination()) ) {
e1->SetDestination(e2->Destination());
e2 = path.erase(e2);
} else {
e1 = e2;
++e2;
}
}
}

28

http://wawworld.me


29

http://wawworld.me


void Raven_PathPlanner::SmoothPathEdgesPrecise(std::list<PathEdge>& path)
{
std::list<PathEdge>::iterator e1, e2;
e1 = path.begin();
while (e1 != path.end()) {
e2 = e1;
++e2;
while (e2 != path.end()) {
if ( m_pOwner->canWalkBetween(e1->Source(), e2->Destination()) ) {
e1->SetDestination(e2->Destination());
e2 = path.erase(++e1, ++e2);
e1 = e2;
--e1;
} else {
++e2;
}
}
++e1;
}
}

30

http://wawworld.me


31

http://wawworld.me


std::vector<std::vector<int> > CreateAllPairsTable(const graph_type& G)
{
enum {no_path = -1};
std::vector<int> row(G.NumNodes(), no_path);
std::vector<std::vector<int> > shortest_paths(G.NumNodes(), row);

for (int source=0; source<G.NumNodes(); ++source)
{
Graph_SearchDijkstra<graph_type> search(G, source);
std::vector<const GraphEdge*> spt = search.GetSPT();

32

http://wawworld.me


for (int target = 0; target<G.NumNodes(); ++target)
{
if (source == target) {
shortest_paths[source][target] = target;
} else {
int nd = target;
while ((nd != source) && (spt[nd] != 0))
{
shortest_paths[spt[nd]->From][target]= nd;
nd = spt[nd]->From;
}
}
} //next target node
} //next source node
return shortest_paths;
}

33

http://wawworld.me


34

http://wawworld.me


std::vector<std::vector<double> > CreateAllPairsCostsTable(const graph_type& G)
{
std::vector<double> row(G.NumNodes(), 0.0);
std::vector<std::vector<double> > PathCosts(G.NumNodes(), row);
for (int source=0; source<G.NumNodes(); ++source)
{
Graph_SearchDijkstra<graph_type> search(G, source);
for (int target = 0; target<G.NumNodes(); ++target)
{
if (source != target) {
PathCosts[source][target]= search.GetCostToNode(target);
}
}//next target node
}//next source node
return PathCosts;
}

35

http://wawworld.me


36

http://wawworld.me


template <class graph_type, class heuristic>
int Graph_SearchAStar_TS<graph_type, heuristic>::CycleOnce()
{
if (m_pPQ->empty()) {
return target_not_found;
}
int NextClosestNode = m_pPQ->Pop();
m_ShortestPathTree[NextClosestNode] = m_SearchFrontier[NextClosestNode];
if (NextClosestNode == m_iTarget) {
return target_found;
}
Graph::ConstEdgeIterator EdgeItr(m_Graph, NextClosestNode);
for (const GraphEdge* pE=EdgeItr.beg(); !EdgeItr.end(); pE=EdgeItr.nxt() {
/* SAME AS IN PREVIOUS A* ALGORITHM */
}
return search_incomplete;
}

37

http://wawworld.me


template <class edge_type>
class Graph_SearchTimeSliced
{
public:
enum SearchType{AStar, Dijkstra};
private:
SearchType m_SearchType;
public:
Graph_SearchTimeSliced(SearchType type):m_SearchType(type){}
virtual ~Graph_SearchTimeSliced(){}
virtual int CycleOnce()=0;
virtual std::vector<const edge_type*> GetSPT()const=0;
virtual double GetCostToTarget()const=0;
virtual std::list<PathEdge> GetPathAsPathEdges()const=0;
SearchType GetType()const{return m_SearchType;}
};

38

http://wawworld.me


class Raven_PathPlanner
{
private:
Graph_SearchTimeSliced* m_pCurrentSearch;
/* EXTRANEOUS DETAIL OMITTED */
public:
bool RequestPathToItem(unsigned int ItemType);
bool RequestPathToTarget(Vector2D TargetPos);
int CycleOnce()const;
Path GetPath();
};

39

http://wawworld.me


int Raven_PathPlanner::CycleOnce()const
{
assert (m_pCurrentSearch &&
"<Raven_PathPlanner::CycleOnce>: No search object instantiated");
int result = m_pCurrentSearch->CycleOnce();
if (result == target_not_found) {
Dispatcher->DispatchMsg(SEND_MSG_IMMEDIATELY,
SENDER_ID_IRRELEVANT, m_pOwner->ID(),
Msg_NoPathAvailable, NO_ADDITIONAL_INFO);
} else if (result == target_found) {
void* pTrigger =
m_NavGraph.GetNode(m_pCurrentSearch->GetPathToTarget().back()).ExtraInfo();
Dispatcher->DispatchMsg(SEND_MSG_IMMEDIATELY,
SENDER_ID_IRRELEVANT, m_pOwner->ID(),
Msg_PathReady, pTrigger);
}
return result;
}

40

http://wawworld.me


template <class path_planner>
class PathManager
{
private:
std::list<path_planner*> m_SearchRequests;
unsigned int m_iNumSearchCyclesPerUpdate;
public:
PathManager(unsigned int NumCyclesPerUpdate);
void UpdateSearches();
void Register(path_planner* pPathPlanner);
void UnRegister(path_planner* pPathPlanner);
};

41

http://wawworld.me


template <class path_planner>
inline void PathManager<path_planner>::UpdateSearches()
{
int NumCyclesRemaining = m_iNumSearchCyclesPerUpdate;
std::list<path_planner*>::iterator curPath = m_SearchRequests.begin();
while (NumCyclesRemaining-- && !m_SearchRequests.empty())
{
int result = (*curPath)->CycleOnce();
if ( (result == target_found) || (result == target_not_found) ) {
curPath = m_SearchRequests.erase(curPath);
}
else {
++curPath;
}
if (curPath == m_SearchRequests.end()) {
curPath = m_SearchRequests.begin();
}
}//end while
}

42

http://wawworld.me


bool Raven_PathPlanner:: RequestPathToItem(unsigned int ItemType)
{
GetReadyForNewSearch();
return false;
}

typedef FindActiveTrigger<Trigger<Raven_Bot> > term_con;
typedef Graph_SearchDijkstra_TS<Raven_Map::NavGraph, term_con> DijSearch;
m_pCurrentSearch = new DijSearch(m_pWorld->GetNavigationGraph(),
ClosestNodeToBot, ItemType);
m_pWorld->GetPathManager()->Register(this);
return true;
}

43

http://wawworld.me


44

http://wawworld.me


45

http://wawworld.me


46

http://wawworld.me


47

http://wawworld.me


Edge next = GetNextEdgeFromPath(path)
//in a simple navgraph the edge cost is the length of the edge
ExpectedTimeToReachPos = next.cost / Bot.MaxSpeed
//factor in a margin of error
MarginOfError = 2.0;
ExpectedTimeToReachPos += MarginOfError;

48

http://wawworld.me


49

http://wawworld.me


실질적인 길 계획하기

Recommended

Recommended

More Related Content

More from Hoseo University

More from Hoseo University (7)

실질적인 길 계획하기