Generating Paths with WFC

Generating Paths with WFC

Hugo Scurti
McGill University
Montréal, Québec, Canada
hugo.scurti@mail.mcgill.ca \AndClark Verbrugge
McGill University
Montréal, Québec, Canada
clump@cs.mcgill.ca
Abstract

Motion plans are often randomly generated for minor game NPCs. Repetitive or regular movements, however, require non-trivial programming effort and/or integration with a pathing system. We here describe an example-based approach to path generation that requires little or no additional programming effort. Our work modifies the Wave Function Collapse (WFC) algorithm, adapting it to produce pathing plans similar to an input sketch. We show how simple sketch modifications control path characteristics, and demonstrate feasibility through a usable Unity implementation.

Generating Paths with WFC


Hugo Scurti McGill University Montréal, Québec, Canada hugo.scurti@mail.mcgill.ca                        Clark Verbrugge McGill University Montréal, Québec, Canada clump@cs.mcgill.ca

1 Introduction

Generating randomized paths for Non-Player Characters (NPCs) is a common task in game design. Simple random walks, however, are unsatisfying, in tending to unrealistic, jagged, fractal-like trajectories with erratic space coverage (?). Better results are possible by making use of higher-level navigation models, such as a waypoint graphs or flow models, but it is in general not an easy task to do for non-programmers, requiring substantial algorithmic development and significant programming effort to ensure simple, frequently desired properties, such as avoiding self-intersection, forming closed loops, and encircling obstacles.

In this work we describe an example-based approach to path generation with a simple, flexible interface. Our design is based on the Wave Function Collapse (WFC) algorithm (?), an example-based approach to texture generation. We modify and augment WFC to form a workflow that takes a representative path design and game level as input, and produces a usable set of paths respecting the given path properties and level (obstacle) constraints. Simple modifications to the input path design can be done with any image editor, and can then be used to control properties of the resulting paths. Our approach is realized in the Unity framework, and we show how the algorithm scales to significant, practical level sizes. For easy use and experimentation, the tool is able to read in actual game levels expressed in ASCII form, as from the Moving AI benchmark suite (?).

Contributions of our work are as follows:

  • We define modifications to the basic WFC algorithm to allow for small, generic images to be used as general models of path design. Basic, easily modified properties of the image then control useful properties of the path output. Our approach includes non-trivial changes necessary to accommodate the densely constrained output context of typical game levels.

  • A complete realization in Unity is shown and made available 111https://github.com/hugoscurti/path-wfc , including a full workflow that reads in game levels and generates abstract path data structures. This work includes post-processing steps to filter and smooth the output paths.

2 WFC Background

Our approach builds heavily on the Wave Function Collapse algorithm developed by ? (?), more precisely the overlapping version of the algorithm. This algorithm builds random output textures based on smaller input textures by looking at overlapping patterns in the input texture sample. Understanding this algorithm is critical to understanding our modifications, so we summarize the main steps below. Further detail can be found in the code itself.

  1. Extract all possible unique patterns from a discretized input image; the frequency of each unique pattern in the input is also later used as a sampling distribution.

  2. Compute all the possible overlap combinations between each pattern. The (im)possibility of overlap between patterns results in the main set of constraints used to build an output image.

  3. Each discretized tile in the output sample maintains a list of legal patterns that could define the pixel value(s) in that tile. Absent any constraints, such as at the start of the algorithm, every pattern is legal in any tile.

  4. Choose a tile in the output sample and commit the value based on one of the legal patterns that cover the tile. This choice follows an entropy calculation that looks for the tile that has the fewest available patterns, and thus is most constrained. The frequency distribution of basic patterns computed in step 1 is used to bias selection of the pattern. This is referred to as the observe step of the algorithm.

  5. The overlap combinations computed in step 2 are used to filter out any now illegal patterns covering adjacent positions, and this is applied recursively throughout the output image. This is referred to as the propagate step.

  6. Repeat steps 4 and 5, observing and propagating until no further progress can be made. At that point either all tiles are fixed to one pattern (the algorithm succeeded), or at some point a tile has no more patterns available (the algorithm failed). In the latter case the algorithm is restarted with a different random seed.

The original implementation adds a few helpful options for texture generation, such as the ability to set boundary patterns, wrap periodically, and extend the range of available patterns by adding rotations and reflections of patterns sampled from the input.

3 WFC for Path Generation

We aim to use WFC to enable example-based path generation. A user supplies a single path sketch, showing an example path, and this is applied to an output level, filling the level with paths that have characteristics similar to the original example.

Unfortunately, while the basic WFC algorithm excels at creating randomized images respecting the constraints of immediate pattern adjacency, it has difficulty guaranteeing non-local properties. For path generation we require a mixture of local properties, such as angle of movement and proximity to obstacles, and properties that are highly non-local, such as control over relative shape, the ability to form closed curves, and encircle/contain other features. Our output images are also existing game levels, already densely constrained by obstacles, complicating the creation of initial constraints and making WFC’s core trial-and-error approach highly inefficient, or even impossible. Below we describe 3 main techniques we used to modify WFC to better handling pathing.

3.1 Output constraints and pre-processing

The original WFC algorithm lets users fix specific tiles in the output to enforce initial output constraints. This builds on the basic algorithm process, manually choosing/reducing the set of legal patterns at a specific location and propagating the resulting constraints. For a large map, filled with obstacles, this would be extremely tedious, and some initial pre-processing is thus necessary to dynamically fix tiles in the output to guarantee the result continues to faithfully represent the original game level.

The process is essentially a batched, automated version of the basic manual fixing. We filter the input level representation, constructing an initial output image with tiles designed as either free-form, pathable space (represented by a white pixel) or obstacles (represented by a red pixel); path fragments (black pixels) could also be incorporated. Interiors of obstacles are thus constrained to a single pattern based on being filled with a single, unique colour, while the patterns permitted to cover perimeters of obstacles are reduced to match the boundary edge.

Figure 1: Different outputs making the algorithm succeed (output 1) and fail (output 2).

The process is flexible, and also provides early warning of unsatisfiable constraints. Figure 1 shows a specific Input path image/template, representing a path encircling an obstacle. For Output 1 a solution is possible; a level such as Output 2, however, fails, as the notched obstacle cannot be filled by any pattern found in the input.

3.2 Arbitrary colours as “stretch space”

An important goal is that generated paths have at least some heuristic, qualitative similarity to the example input. Overly literal interpretation of the input image, however, tends to generate paths that are either too strict or under-constrained. Figure 2 shows examples of trying to use an input sketch to imply paths should generally encircle the obstacle. In example 1 the result is under-constrained. The distance between the example path and the obstacle means patterns exist that do not contain both the path and obstacle colours. Generated paths thus meander arbitrarily, more or less oblivious to the obstacle. Example 2 shows an attempt to solve this by putting the path close to the obstacle, but this results in only generating paths strictly one unit away from the obstacle (or from another path edge).

Figure 2: Execution of the algorithm without using stretch space.

We introduce the notion of stretch space to alleviate this issue. We use a unique, designated color in the input image to represent the space between an obstacle and the path that goes around it. We make sure that one pattern can be filled entirely with this color so that the overlapping nature of the algorithm will make it overlap with itself, therefore making the space between obstacles and paths stretchable. This helps generated paths behave more closely to their inputs as it restricts the sets of overlapping patterns for each pattern that contains a path.

Figure 3 shows an example, using light blue to indicate stretch space. The blank area of the output can then be filled with stretch space, ensuring path pixels have some relation to obstacles (or other path segments): blue patterns may be selected to extend the stretch area, eventually and necessarily reaching path/obstacle patterns that close the path.

Figure 3: Example of using stretch space propagating out from an obstacle corner. On the top, the stretching is terminated by a vertical path line, defining a generated path one unit away from the obstacle. The bottom instance shows a different, random choice, selecting empty stretch space to push the path tile away further. Note that similar to Gumin’s implementation, the images show progress during the execution of the algorithm, averaging the color from the set of all surrounding legal patterns until it is filled by one pattern, rather than just showing blank/white pixels. This results in a blurry effect while patterns are being unveiled.

Using stretch space allows for greater versatility and generally better correspondence with the path behaviour of the input example. It is, however, a heuristic trade-off in permissiveness. Patterns will typically exist with no obstacle pixels, allowing construction of (usually smaller) paths enclosing only stretch space, and thus not necessarily encircling an obstacle. We give the option to remove these as a post-processing step.

3.3 Masks

Input examples are meant to be simple, schematic drawings. Outside trivial situations, these are unlikely to include all possible patterns needed to fill the output level map—complex and varied obstacle and boundary shapes in the intended level space generate output constraints that will in general not be satisfiable. Path generation, however, has the advantage over other WFC applications in that it is not strictly necessary to find a complete solution. A partial solution that establishes paths can be a sufficient, even if the set of pattern constraints cannot be fully propagated to cover every tile in the output.

We thus introduce masks to help cover tiles for which we do not have an appropriate input pattern. We do this by automatically creating patterns from the output map. We analyze the output for all patterns that contain obstacles. Then, for each pattern, we replace white tiles around obstacles by various masks depending on their relative position to an obstacle. Tiles that are adjacent to an obstacle contain a mask that allows everything but the path color and all other tiles contain a mask that allows any color. This design enables input-derived patterns to propagate up to obstacles, but not fail constraints due to being unable to align with the exact obstacle boundary—even if not explicitly sketched in the input example, any obstacle in the output can be dealt with and can have paths, free space and stretch space around it.

Figure 4: Execution of the algorithm using masks on output boundaries. Masks are represented as transparent tiles.

Figure 4 shows an example. The input example does not include a concave notch in the obstacle, and thus a naive WFC will be unable to find a solution given the limited set of patterns present in the input. Using a mask we can effectively ignore the aberration, successfully generating a cyclic path around the obstacle even though no pattern from the input fits the upper right notch.

Masks obviously represent a trade-off between successful generation and strictly following input constraints. Our tool design allows masks to be toggled on or off, depending on the path generation goals.

3.4 Post processing

The heuristic nature of our approach is augmented with some post-processing steps to filter out degenerate constructions, help visualize results, and generally better prepare paths for integration into a game environment. Figure 5 shows an execution flow for of all processing steps. With the exception of the initial conversion, all steps mentioned below are optional and can be used independently.

Conversion to usable path

The WFC image output is converted into a waypoint format that can be used in a game environment. We generate paths by following path tiles incrementally until a path is complete. The actual 3D model requirements are of course game dependent, but we provide a baseline conversion for easy visualization, using simple cubes for obstacles, and line renderers for paths.

Path filtering

As a result of using overlapping patterns and masks, outputs may contain smaller paths that are not necessarily appealing. We enable the option to filter out paths that are smaller than a specified length threshold.

Path Simplification

Depending on the input patterns, some paths can get complicated and have a significant amount of redundant turns or detours. We provide a post-processing option to simplify paths, based on the Ramer-Douglas-Peucker algorithm (RDP) (??) to remove redundant vertices. We modified the algorithm to avoid obstacle intersection when simplifying a path segment.

Path Smoothing

Since they are generated using patterns, output paths naturally have sharp turns and corners. We thus also provide smoothing using ?’s curve generation algorithm (?). Similar to path simplification, we modified the algorithm to make sure that we do not cut a corner if a modified path segment intersects an obstacle.

Figure 5: Execution of all post-processing steps in their respective order. Output map is “arena” from the Dragon Age: Origins benchmark set.

4 Experimentation

The precise intention of a user’s input path example is of course open to multiple interpretations. Experimental work is thus aimed at providing proof-of-concept evidence that the input image does allow for control over the output, with a qualitatively clear correspondence of features. We also address performance concerns, showing that the process scales to relatively large output maps typical of modern games.

4.1 Setup

Our setup is based on a custom Unity implementation of our modified WFC algorithm. We use custom inputs, extracting patterns of size as sufficient to represent useful path properties without introducing major scaling issues. Input and output 2D maps use small monochromatic sprites to represent tiles and interactively show the execution of the algorithm. When the execution succeeds, post processing steps can be applied to generate paths in a 3D representation of the output map, along with an agent that can walk through generated paths. The algorithm was used on a 64-bit Windows 10 machine with an Intel Core i5-4200U CPU running at 1.60 GHz, an Nvidia GeForce GT 750M GPU, and 8 GBs of RAM. The algorithm was tested with maps representing game levels from Dragon Age: Origins and Baldur’s Gate II, as extracted from the Moving AI benchmark sets (?).

4.2 Controlling the output

Output properties are affected by changes to the base WFC algorithm, as well as by the given input example. Below we show representative examples to illustrate the range of results and give an indication of how the output can be controlled.

Stretch space

Use of stretch space was motivated by the desire for better correspondence with the input. Both types of input, with and without stretch space, however, generate interesting paths that may be useful for different purposes, with the latter having a much higher degree of randomness.

Figure 6: Comparison between output generated without and with stretch space.

Figure 6 shows the effect of using stretch space or not in an otherwise identical input/output context. In contrast to example 1 from figure 2 where paths are not closed, execution without stretch space (figure 6, left) in a larger output bounded by obstacles results in reasonable closed routes, although more meandering than the rectangular paths generated by using stretch space (right). The effect of stretch space is driven by the constraints between pattern overlaps, where having different colors inside and outside the cyclic path prevents corners from acting as both inside and outside turns. This gives us two different ways of generating paths with one input, using a less constrained interpretation to generate a broader range of outputs, or a stricter view that generates results more similar to the shape of the input path.

Frequency distribution

Using weights to select patterns also gives us control over the outcome of the algorithm. We use the same pattern selection mechanism as in the base WFC algorithm: the frequency of each pattern extracted from the input gives a frequency distribution, which is then used to calculate the entropy of given tiles in order to select the next tile and pattern during the observe step. The relative extent of identical features in the input thus gives control over the likelihood of choosing a corresponding pattern in the output. Figure 7 shows the effect. Even though horizontal and vertical rectangles and squares have identical sets of input patterns, the relative number of each pattern biases the output.

Figure 7: Comparison between output generated with different types of input. Rotations and reflections are disabled in order to accentuate the differences.

Further control is possible using the same mechanism. Tuning the ratio of white tiles to stretch tiles, for example, will affect the output in terms of how many paths there will be and how big paths will get.

Uniform distribution

Pattern/tile selection can also be done without regard to pattern frequency. Figure 8 shows two outputs generated from the same input and random seed. The first output uses the normal frequency distribution, while the second output uses a uniform distribution. As we can see, the preponderance of vertical rectangles apparent in the first case is not reproduced in the second output, since the distribution of patterns is the same for each pattern. There is also less overall coverage, due to the fact that stretch space tiles are now less frequent than in the first output.

Figure 8: Comparison between output generated with different types of distribution. Rotations and reflections are disabled.

Different input/output combinations

To support the argument that the algorithm works for different combinations of input and output, we show examples on 2 larger inputs, namely Arena2 () and Lak519d () from the Dragon Age: Origins benchmark set.

Figure 9: Example of execution with the Arena2 map.

Figure 9 shows a result of the algorithm on the Arena2 map. Here we used a complex polygon as the input, incorporating both a concave notch and edges with different angles. Rotations are reflections are also enabled. The resulting paths are more organic, with many more complex turns and routes.

Figure 10: Example of execution with the Lak519d map.

Figure 10 shows a result on the Lak519d map using an octagon as the input. For this input, enabling rotations and reflections is irrelevant as it would add no additional pattern. The more limited pattern set available in this output results in output quite different from figure 9, with path shapes that have a strong similarity to the input. Note that here we also added obstacle tiles in the input’s corners to cover up white space and even out the ratio between white space and stretch space.

4.3 Performance

The performance of WFC mainly depends on 2 factors, the number of patterns extracted from the input, as well as the size of the generated output. Our design integrates optimizations introduced by ? (?). We also make use of Unity’s Job System, using it to help parallelize the post-processing path generation step.

Measurements are gathered by running the algorithm 10 times on each test set and compare the change in average execution time. We discard the first execution for each test as a cache warm up.

Input Output Nb. Patt. Size Time (sec.) Std Dev. Poly 2 arena1 206 0.89 0.012 Poly 2 orz000d 253 7.61 0.118 Square lak519d 304 49.59 0.821 Octagon lak519d 320 53.11 1.024 Poly 1 lak519d 348 58.71 0.436 Poly 2 lak519d 376 61.02 1.388 Poly 2 arena2 267 78.43 0.431

Table 1: Average time in seconds for varying inputs/outputs.

Table 1 shows executions with different inputs and outputs. We used a specific input (Poly 2) with varying outputs as well as a specific Output (lak519d) with varying inputs. As shown by the average execution time (column Time), using inputs that generate more patterns increases the running time, however execution time grows notably more as the output size grows. Despite these variations, execution on significantly large maps is done in a reasonable amount of time.

5 Related work

Our work relies heavily on the WFC algorithm as it is an adaptation of the WFC overlap model. The WFC algorithm has seen a few notable ports and forks. ? released a paper on WFC in which they describe the algorithm in depth, discuss its influence and contextualize it in terms of constraint solving (?). ? have developed a faster version of the algorithm written in C++ (?) which introduces modifications such as reducing the number of overlaps per pattern processed by the algorithm. ? have experimented with hiding messages in the generated images from the tiled model, with an emphasis on the fact that embedded images are not distinguishable from normal generated images (?). Among a few others, ? also developed a 3D version of the tiled model to generate 3D images using voxels (?).

5.1 Pcg

Path generation itself is generically part of the field of Procedural Content Generation (PCG). This field applies mostly to games and consists of algorithms that generate content such as textures, levels, terrains, quests, items, or other game-related concepts. The key idea is that the content is created in a random and algorithmic way with minimal user input, in contrast to content being manually crafted by game designers. Many generative techniques have been explored, including constraint models, based on understanding the rhythm or pacing of player experience, such as the ?’s Tanagra tool for 2D platformer levels (?), and machine-learning approaches that demonstrate it is possible to construct levels without domain-specific knowledge (?). Although less common, PCG algorithms have been applied to path generation previously as well. ? (?) developed a tool to randomly place guards and cameras in stealth game levels. Their approach concentrated on visibility and coverage properties, aiming to heuristically control level difficulty. More information on PCG can be found in ?’s book (?).

5.2 Roadmap Generation

Higher-level navigation systems, such as roadmaps, can also be used as a basis for creating randomly wandering NPC motion, presenting seemingly goal-directed behaviour by defining random path choices at a larger scale. Paths based on optimal roadmaps, however, tend to scrape obstacles (?), which is both not human-like, and a source of error in game simulation. For games, NPC movement is better shifted away from obstacles. Convex decompositions or navigation meshes can be used to give more movement freedom. Triangulations are a natural choice in this respect, and many systems build roadmaps from the triangulation dual. ? (?), for instance, show that it is efficient to build a graph for pathfinding by using constrained Delaunay triangulations, a technique also used by ? (?) to build roadmaps with controlled distance from obstacles. ? (?) generate roadmaps by randomly selecting candidate points on the boundaries of a shape and using the midpoint between lines connecting pairs of candidates to form a roadmap.

In defining routes that well avoid obstacles, roadmap algorithms tend to approximate the medial axis skeleton (?), a simplified graph that defines points equally distant from internal obstacles. This has a natural appeal for roadmaps, and thus pathing, and use of the medial axis has been experimented with by many authors (??). ? (?) has taken this concept even further and used medial skeletons in a 3D environment (2D map with 3rd dimension as time) to generate roadmaps in a dynamic environment for stealth games.

Other pathfinding systems also lend themselves to path generation. The hierarchical pathfinding algorithm developed by ? (?) creates an abstract graph of a map by separating the map into clusters, which could be adapted to be used generatively. Search graphs of various forms can be used in a similar fashion. Rapidly exploring random trees (RRTs), for example, can be used to generate random paths in fixed maps (?). The idea of RRTs is to grow a randomized tree structure from a certain position in order to fill the map with many different random paths. This could be adapted to generate random meandering paths by setting a starting point and letting the RRT search grow, perhaps also including constraints on how it connects new nodes for controlling variety.

In contrast to pathfinding, dynamic systems can also be used to randomly move agents around obstacles. One can use steering behaviours (?) along with obstacle attraction (?) to make an agent move around an obstacle. In a similar fashion, using flow fields for crowd pathing (?), one can generate flow fields that gravitate around obstacles and make agents move along those flow fields.

6 Conclusion & Future Work

In this paper, we have presented a modification to the Wave Function Collapse algorithm that handles random path generation using input texture samples and fixed output maps. The algorithm extends the original WFC algorithm by generating paths similar to the input by using stretch space, and by using masks to enable new patterns based on the shape of obstacles from the output map. We have included post-processing options to filter out small paths and to make remaining paths smoother. We presented a convenient tool developed in Unity that lets any user, with our without programming knowledge, use the algorithm for path generation purposes.

Using a texture generation algorithm to generate paths has a few inherent limitations. First of all, there is no defined way to enforce true global constraints on the output to satisfy the global shape of the input path. Moreover, since paths are defined by pixels, intersecting paths introduce ambiguity in converting the 2D image into waypoints for a game level.

Future work on the algorithm could include using heuristics on intersecting tiles to determine which neighbour is the next path segment. Further development include enforcing additional constraints to make paths meet certain evaluation criteria, such as the number of turns taken or the number of obstacles that paths enclose. A more complex constraint would be to augment our algorithm with a frequency distribution on pairs of patterns, which could bind the selection of a pattern to previously selected neighbour patterns.

References

  • [Amato and Wu 1996] Amato, N. M., and Wu, Y. 1996. A randomized roadmap method for path and manipulation planning. In Proceedings of IEEE International Conference on Robotics and Automation, volume 1, 113–120 vol.1.
  • [Blum 1967] Blum, H. 1967. A transformation for extracting new descriptors of shape. In Wathen-Dunn, W., ed., Models for the Perception of Speech and Visual Form. Cambridge: MIT Press. 362–380.
  • [Botea, Müller, and Schaeffer 2004] Botea, A.; Müller, M.; and Schaeffer, J. 2004. Near optimal hierarchical path-finding. Journal of game development 1(1):7–28.
  • [Chaikin 1974] Chaikin, G. M. 1974. An algorithm for high-speed curve generation. Computer Graphics and Image Processing 3(4):346 – 349.
  • [Demyen and Buro 2006] Demyen, D., and Buro, M. 2006. Efficient triangulation-based pathfinding. In Proceedings of the 21st National Conference on Artificial Intelligence - Volume 1, AAAI’06, 942–947. AAAI Press.
  • [Douglas and Peucker 1973] Douglas, D. H., and Peucker, T. K. 1973. Algorithms for the reduction of the number of points required to represent a digitized line or its caricature. Cartographica: The International Journal for Geographic Information and Geovisualization 10(2):112 – 122.
  • [Emerson 2013] Emerson, E. 2013. Crowd pathfinding and steering using flow field tiles. Game AI Pro: Collected Wisdom of Game AI Professionals 307–316.
  • [Fajen et al. 2003] Fajen, B. R.; Warren, W. H.; Temizer, S.; and Kaelbling, L. P. 2003. A dynamical model of visually-guided steering, obstacle avoidance, and route selection. International Journal of Computer Vision 54(1-3):13–34.
  • [Fehr and Courant 2018] Fehr, M., and Courant, N. 2018. fast-wfc. https://github.com/math-fehr/fast-wfc. Github repository.
  • [Guibas, Holleman, and Kavraki 1999] Guibas, L. J.; Holleman, C.; and Kavraki, L. E. 1999. A probabilistic roadmap planner for flexible objects with a workspace medial-axis-based sampling approach. In Proceedings 1999 IEEE/RSJ International Conference on Intelligent Robots and Systems: Human and Environment Friendly Robots with High Intelligence and Emotional Quotients, volume 1, 254–259.
  • [Gumin 2016a] Gumin, M. 2016a. Basic3DWFC. https://bitbucket.org/mxgmn/basic3dwfc/src/master/. Bitbucket repository.
  • [Gumin 2016b] Gumin, M. 2016b. WaveFunctionCollapse. https://github.com/mxgmn/WaveFunctionCollapse. Github repository.
  • [Karth and Smith 2017] Karth, I., and Smith, A. M. 2017. WaveFunctionCollapse is constraint solving in the wild. In Proceedings of the 12th International Conference on the Foundations of Digital Games, FDG ’17, 68:1–68:10. New York, NY, USA: ACM.
  • [Lavalle 1998] Lavalle, S. M. 1998. Rapidly-exploring random trees: A new tool for path planning. Technical Report TR 98-11, Iowa State University.
  • [Lawler 1991] Lawler, G. F. 1991. Intersections of random walks. Birkhäuser.
  • [Lefebvre, Wei, and Barnes 2018] Lefebvre, S.; Wei, L.-Y.; and Barnes, C. 2018. Informational texture synthesis. https://hal.inria.fr/hal-01706539/file/infotexsyn.pdf. working paper or preprint.
  • [Lens and Boigelot 2016] Lens, S., and Boigelot, B. 2016. From constrained Delaunay triangulations to roadmap graphs with arbitrary clearance. CoRR abs/1606.02055. http://arxiv.org/abs/1606.02055.
  • [Nilsson 1969] Nilsson, N. J. 1969. A mobile automaton: An application of artificial intelligence techniques. In 1st International Conference on Artificial Intelligence, 509–520.
  • [Ramer 1972] Ramer, U. 1972. An iterative procedure for the polygonal approximation of plane curves. Computer Graphics and Image Processing 1(3):244 – 256.
  • [Reynolds 1999] Reynolds, C. W. 1999. Steering behaviors for autonomous characters. In Game developers conference, volume 1999, 763–782.
  • [Shaker, Togelius, and Nelson 2016] Shaker, N.; Togelius, J.; and Nelson, M. J. 2016. Procedural Content Generation in Games: A Textbook and an Overview of Current Research. Springer.
  • [Singh 2015] Singh, D. 2015. Using medial skeleton for path finding in dynamic stealth games. Master’s thesis, McGill University, Montréal, Canada.
  • [Smith, Whitehead, and Mateas 2010] Smith, G.; Whitehead, J.; and Mateas, M. 2010. Tanagra: A mixed-initiative level design tool. In Proceedings of the Fifth International Conference on the Foundations of Digital Games, 209–216. ACM.
  • [Snodgrass 2018] Snodgrass, S. 2018. Markov Models for Procedural Content Generation. Ph.D. Dissertation, Drexel University.
  • [Sturtevant 2012] Sturtevant, N. 2012. Benchmarks for grid-based pathfinding. Transactions on Computational Intelligence and AI in Games 4(2):144 – 148.
  • [Wilmarth, Amato, and Stiller 1999] Wilmarth, S. A.; Amato, N. M.; and Stiller, P. F. 1999. MAPRM: a probabilistic roadmap planner with sampling on the medial axis of the free space. In Proceedings 1999 IEEE International Conference on Robotics and Automation, volume 2, 1024–1031 vol.2.
  • [Xu, Tremblay, and Verbrugge 2014] Xu, Q.; Tremblay, J.; and Verbrugge, C. 2014. Generative methods for guard and camera placement in stealth games. In Tenth Annual AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment (AIIDE 2014).
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
254246
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description