Hierarchical Path-finding Theta*: Combining Hierarchical A* with Theta*

Transcription

1 Hierarchical Path-finding Theta*: Combining Hierarchical A* with Theta* Linus van Elswijk 1st April

2 Contents 1 Problem Statement Research Question Subquestions Motivation 4 3 Theoretical scope A* HPA* Theta* Strategy 7 5 Time schedule Finnished work February (16 hours) March (42 hours) Planning Deadlines

3 1 Problem Statement One of the most, if not the most common problem for AI in computer games is the problem of finding a path from position A to B. The problem can solved by translating the search space into a graph and then using a graph-search algorithm to find a path from the start to goal within the graph. The game-industy standard is to use (one of the many variants of) the classic A* algorithm(hart et al., 1968). Some variants are specifically designed to work with dynamic environments. In dynamic environments, replanning is needed when a previously planned path is found to be blocked during the execution of the path. Dynamic variants of A*, such as D*(Stentz, 1994), can do the replanning more efficiently than classic A*. Other variants, such as Hierarchical Path-Planning A*(Botea et al., 2004) 1 use a hierarchical approach to the planning and provide a speed-up when working with large maps/graphs. A recent variant is specifically designed to work with non-discrete maps. With classic A*, the movement options in the search algorithm are limited to the edges between the nodes of the search graph. These new variants make use of the fact that the nodes in the graph all represent a point in space. They use this knowledge to find shortcuts between the points/nodes within the real space, instead of just looking at the graph representing it. We will call this variant and any-angle variant from now on. There is an algorithm that combines the dynamic variant with the hierarchical variant and also an algorithm that combines the dynamic variant with the any-angle approach. However, there is (to my knowledge) no literature on combining the any-angle variants with the hierarchical variants. In this paper I will present a new algorithm, Hierarchical Path-Finding Theta*, that strives to succesfully combine to combine the properties of the any-angle and hierarchical variants of A*. 1 Hierarchical Path-Planning A* should not be confused with Hierarchical A*(Holte et al., 1996), which uses a different approach to path-finding. 3

4 1.1 Research Question This leads us to the following research question: Does Hierarchical Path-Finding Theta* succesfully combine the properties of Theta* and HPA*? So when exactly can we conclude that the properties are combined succesfully? Our algorithm should have atleast the following properties: The average solution path-length should be within 5% of the average solution path-lenght of classic A*. The average computation time should not be more than twice the average computation time of HPA* The average number of heading changes in a solution path should be within 50% of the number of heading changes of Theta* We will only call the combination succesful if all three of the requirements are met. 1.2 Subquestions To find an answer to the research question we have to find an answer to the following sub-questions: 1. How do the existing algorithms, HPA* and Theta* work? 2. How can these algorithms be combined? 3. In which environments should we test the algorithms to get a fair result? 4. How do the algorithms perform in the test-environments? The answer to subquestion 1 will be in the form of a literature review. The answer to subquestion 2 will be in the form of psuedo-code, that will allow us to implement the new algorithm. The answer to subquestion 3 will tell us how the performance test will be executed. We can answer subquestion 4 by running the tests and analysing the results. This will also allow us to answer the research question. 2 Motivation As we stated earlier, path-finding is one of the most common problems the AI has to deal with in today s computer games. Especially in computer games, we tend to demand a lot from a path-finding algorithm. The first, and probably the most important requirement is that the algorithm returns paths of reasonable length. It doesn t have to return optimal paths, but players don t want the computer controlled units to take long detours instead of moving directly to their goal. Another 4

5 important property of the path-finding algorithm is that it can find a path efficiently. You don t want the path-planning algorithms to slow the game down, so the algorithm should be able to find a path fast. The less processing time is needed for the path-planning algorithm, the more processing time can be spend on other areas of the game, such as the graphics. The algorithm complexity should also scale well with the complexity of the problem-space. We don t want the algorithm to slow down immensely when operating on large maps, making the algorithm the deciding factor of the map size. The algorithm should also be able to handle continuous environments and return natural looking paths. A lot of graph-based search-algorithms have to translate continuous maps into a limited set of nodes. If the algorithm limits the movement to the edges between the nodes, unnatural looking zig-zag patterns can occur in the path, because the nodes don t have edges in the desired angle. Classic A* guarantees that the returned path is optimal. Varations of A* have been developed that trade in some of the path optimality to gain other desirable properties. HPA* can find a path faster than A* in large search-spaces. Theta* can find paths without restricting movement to certain angles. However there no literature yet on an algorithm that combines the properties of HPA* and Theta*. An algorithm that can both deal with large search-spaces and continuous environments would be interesting for games. There are also variants of A* that are designed to work with partiallyknown or changing environments. An example of this is D*. Hierarchical D*(Cagigas and Abascal, 2005) (HD*) is a variant of D* that works better on large-maps. There is also a dynamic version of Theta*, called Phi*(Nash et al., 2009). The dynamic properties of these algorithms are also interesting. We could also investigate to combine HD* with Phi*. We chose to restrict ourself to the static algorithms for practical reasons and also because HPA* is somewhat dynamic 2. 2 HPA* can do replanning faster than classic A* according to Botea et al. (2004) 5

6 3 Theoretical scope In this section I will discuss the different algorithms on which the new algorithm, HPT*, will be based. I will first explain how the class A* works. I will then continue with hierarchical A*. After that I will explain Theta*. 3.1 A* The classic A*, as described by Hart et al. (1968), is a form of best-first search(russell and Norvig, 2003). Best-first-search algorithms try to expand the nodes that are closest to the goal first. A heuristic function is used to make an estimation of how close a node is to it s goal before the node is expanded. A* also keeps track of the cost of the path to reach a node. Instead of just expanding the node that is closest to the goal, A* tries to expand the node for which the sum of the estimated distance to the goal and the cost to reach that node is the smallest. You could say that A* tries to expand the nodes with the smallest estimated solution cost first. Hart et al. (1968) proved that A* always finds the optimal path when the heuristic function never underestimates the distance of a node to the goal. 3.2 HPA* Hierarchical Path-Finding A* was first described by Botea et al. (2004). HPA* can provide a large performance boost on large search spaces/graphs when compared to classic A*. HPA* uses one or more levels of abstraction to reduce the complexity of a problem. Abstractions of the searchspace are generated by combining several nodes within a rectangular area on the map. Such a combination of nodes is called a cluster. After generating the clusters, edges between the cluster will be generated. Classic A* is used to see if a cluster can reach it s neighbours. For all neighbours that can be reached, a edge is added to the graph, together with the cost of the A* path that can be used to travel between the clusters. After the edges for the clusters have been generated, the search problem can be run on the graph of clusters instead of the original, low-level, graph. Since the graph of clusters is a lot smaller than the original graph, search problems can be greatly simplified by using the cluster-graph instead of the original graph. If needed, more layers of abstraction can be added by forming clusters of clusters and calculating the edges and their cost for them. HPA* uses classic A* at several points in the algorithm. Classic A* is used to determine the (optimal) path cost to travel between clusters. Classic A* is also used to plan a path from a node to the boundary of the cluster in which the node resides. 6

7 3.3 Theta* Theta*(Nash et al., 2007) is variant of A* that makes uses of the fact that the nodes in the search space all represent a position in (a) space. In the non-discrete space, there is more freedom in movement than in the graph representing the search space. In the graph, you can only move along the edges between the nodes. In the non-discrete space, it is possible to move in any-angle. This is why Theta* is called an any-angle path finding algorithm. 4 Strategy The first step in finding the answer to the research question is studying specification of classic A*, HPA* and Theta*. We need to be able to implement all three of these algorithms for the final test. We want to compare the performance of these three algorithms and the new algorithm, HPT*. This will also allow us to answer subquestion1. We also need to determine on which maps where are going to perform the tests and what the actual path-finding problems will be. Luckily, Bioware has made map tests available for research and testing pathplanning algorithms. They provide both maps, extracted from the game "Baldur s Gate II" and the game "Dragon Age: Origins". The maps can be found on (Sturtevant, 2011). This answers subquestions3. We will also provide psuedo-code of the HPT* algorithm and implement it, answering subquestion2. All algorithms will be implemented in C++ for the test, because C++ is the most used language in game-development at the moment (?). With all algorithms implemented and the test conditions determined, we can run the tests, analyse the results and answer both subquestion4 and the research question. 7

8 5 Time schedule 5.1 Finnished work February (16 hours) Mostly reading existing literature on pathfinding, to get a good overview of the field. Roughly determining what algorithms are available, what the difference are. Deciding an interesting subject to investigate. First research plan March (42 hours) More thorough reading on the following algorithms: A* D* HPA* Theta* Phi* Decided the research question. Final version of the research plan. A* algorithm implemented. Decided how the tests will be performed. 5.2 Planning April 15th April 25th May 16th May 30th June 13th June 20th finish test environment finish HPA* implementation finish Thetha* implementation finish HPT* implementation running the tests and analysing the results Final version of thesis + presentation 5.3 Deadlines Friday, 1st of April Monday, 25th of April Monday, 13th of June Monday, 27th of June Final research plan First version of thesis Second version of thesis Final version of thesis + presentation 8

9 References A. Botea, M. Müller, and J. Schaeffer. Near optimal hierarchical pathfinding. Journal of game development, Daniel Cagigas and Julio Abascal. A hierarchical extension of the d* algorithm. Journal of Intelligent and Robotic Systems, 42: , Peter E. Hart, Nils J. Nilsson, and Bertram Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE Transactions of System Science and Cybernetics, SCC-4(2): , R. Holte, M. Perez, R. Zimmer, and A. MacDonald. Hierarchical A*: Searching abstraction hierarchies efficiently. Proceedings AAAI-96, pages , A. Nash, K. Daniel, S. Koenig, and A. Felner. Theta*: Any-angle path planning on grids. the AAAI Conference on Artificial Intelligence, pages , Alex Nash, Sven Koenig, and Maxim Likhachev. Incremental phi*: Incremental any-angle path planning on grids? In IJCAI 09 Proceedings of the 21st international jont conference on Artifical intelligence, Stuart Russell and Peter Norvig. Artificial Intelligence: A Modern Approach, chapter 4.1 Informed (Heuristic) Search Strategies. Prentice Hall, Anthony Stentz. Optimal and efficient path planning for partially-known environments. In Proceedings of the IEEE international conference on robotics and automation, pages , Nathan Sturtevant. Nathan sturtevant s moving ai lab: Pathfinding benchmarks, April URL 9