Casual Creation of Tile Maps via Authorable Constraint-Based Generators Dan Carpenter, John Thomas Bacher, Henry Crain, Chris Martens Department of Computer Science, North Carolina State University {dcarpen2, jtbacher, hrcrain}@ncsu.edu, martens@csc.nscu.edu Abstract them to configure a small set of parameters and then repeat- Tile-based maps are used in a wide variety of games, includ- edly generate new maps until they find something they like. ing Zelda: Link’s Awakening, Super Mario Bros, and many There is significant potential for a tool that combines the tabletop role-playing games. They represent a relatively sim- benefits of both tile map editors and generators, allowing ple method for designing game worlds, which makes them a users to directly edit the map while also enabling collabo- great medium for casual users. However, creating tile maps ration between the user and a generative system to improve entirely by hand can be tedious, especially for large maps or efficiency and foster creativity. across several map generation tasks. There is potential for Mixed Initiative Co-Creation (MI-CC) systems aim to generative systems to support users in more efficiently and foster this type of productive human-computer collaboration enjoyably creating tile maps, but a more streamlined con- during creative tasks (Yannakakis, Liapis, and Alexopoulos tent generation experience often comes at the cost of reduced control over the generated content. In this paper, we present 2014). By supporting interaction between a human initiative a mixed-initiative map generation tool that supports users in and a computer initiative, with both the human and com- creating customized tile maps by providing complete control puter proactively contributing to a creative task, MI-CC sys- over both the map being generated and the rules governing an tems can lead to truly co-creative experiences. In an MI-CC underlying Answer Set Programming-based generator. Using relationship, the human and computer are able to work in a small palette of rules designed for tile map generation, users harmony to complement each other’s weaknesses. For ex- define constraints on the types of maps the system will gener- ample, the computer can act as an expert guide for a particu- ate, view and edit generated maps, and selectively re-generate lar content creation task by providing suggestions based on sections of the map until they are satisfied. We discuss our an existing body of work, thereby scaffolding a user’s initial current progress on this tool and present several opportuni- exploration of a new domain. The computer can also take on ties for future work, with a particular focus on expanding the capabilities for authoring rule-based tile map generators. the role of an additional worker providing suggestions for parts of the generated content that the user is less interested in focusing their time on. Introduction MI-CC tools can be designed to embody the principles of Tile-based maps are used in many video games, including casual creators (Compton and Mateas 2015), which are ac- Zelda: Link’s Awakening and Super Mario Bros, and table- cessible to users with varying levels of technical knowledge top role-playing games like Dungeons and Dragons and and domain expertise and prioritize the experience that users Pathfinder. There is extensive support for the creation of tile have while exploring a design space in collaboration with a maps and the use of tile maps for creating video games. For generative system. A casual creator is a tool that allows a example, the Tiled map editor (Thorbjørn Lindeijer 2008) user to rapidly explore a range of possibilities and discover has been used in the creation of hundreds of indie games, unusual or novel results. They are meant to be enjoyable to and the popular Unity game engine (Unity Technologies use; the user feels a sense of pride in what they have discov- 2005) features native support for tile maps. For tabletop ered. People can engage with them casually in the sense that role-playing games, map editors like Tiamat Tile Mapper they do not require any background knowledge or training. (RPGObjects.com 2010) and map generators like DunGen In this paper, we present a mixed-initiative tile map cre- (DungeonChannel.com 2019) are useful tools for creating ation tool that implements several casual creator patterns tile maps. Yet, despite the substantial support for the use of (Compton and Mateas 2015) and provides users with a sim- tile maps in games, there is a lack of tools that leverage the ple yet powerful set of controls over the generation of a full capabilities of procedural content generation to support map and the underlying generative system. The tool is built the creation of tile maps. Often, tile map creation tools either around an Answer Set Programming (ASP) constraint-based require users to manually edit every tile on the map or allow generator that the user can modify through a set of natu- Copyright © 2021for this paper by its authors. Use permitted under ral language rules that define characteristics of the maps Creative Commons License Attribution 4.0 International (CC BY that will be generated. ASP was used for constraint solv- 4.0). ing because of its extensive use in procedural content gen- eration tasks, including puzzle and level generation (Smith constraints on the types of games that the system will gen- and Mateas 2011; Neufeld, Mostaghim, and Perez-Liebana erate. These constraints include types of entities (i.e., graph- 2015). Yet, ASP is not very approachable for non-technical ical objects, such as characters), resources (i.e., quantitative users, so we sought to provide some of the content gen- values that define the goals of the game, such as happiness eration power of ASP with a more approachable graphical or confidence), relationships between entities and resources, user interface. In our tool, users construct rules by select- and triggered gameplay events. Constraints in the visual pro- ing options from dropdown menus and typing values into gramming language are translated by Germinate into Gem- input fields, thus ensuring the syntactic validity of each rule. ini intents, which are ASP programs. When users are done These rules are then translated into ASP and used to gener- declaring constraints, they ask Germinate to produce a batch ate tile maps that meet the desired specifications. Rulesets of games that attempt to satisfy the constraints specified by can be saved and loaded, allowing users to design different the user while also introducing additional entities, resources, map generators that they can later refine to meet specific sce- relationships, or triggers. The generated games are presented narios, as well as providing a mechanism for sharing map in a playable form, so users can immediately playtest what generators between users. Additionally, users can directly was created based on their core design intent. Additionally, modify the map that is being created by adding specific tiles the games are displayed in the same visual programming or locking generated sections of the map that they want to language that is used to create the design intent for gener- keep. This allows users to exercise as much control over the ating games. This allows users to clearly see where their map as they desire while supporting iterative refinement in constraints were implemented or modified and to take in- collaboration with the generator. spiration from generated games by pulling new constraints We discuss our progress on the tool’s design and develop- into their core design intent. ment, describing our initial goal of supporting the creation of Imaginarium supports users in the development of pro- individual tile maps and our recent focus on supporting the cedural content generators for tabletop role-playing charac- creation of rule-based tile map generators. We also present ters and items. Users provide structured natural language promising directions for future work, especially opportuni- descriptions of some rules that they want a set of entities ties for expanding the tool’s rule authoring capabilities. (e.g., characters and items) to follow and the system gen- erates entities meeting these requirements. For example, by Related Work enumerating sets of possible characteristics that cats could Mixed-initiative and casual creator tools have been devel- have (e.g., “Cats are white, gray, black, or ginger”), fol- oped to support a wide range of content generation tasks, in- lowed by asking Imaginarium to “Imagine 3 cats”, the sys- cluding the creation of game maps and levels with Tanagra tem will generate three cats that embody some combination (Smith, Whitehead, and Mateas 2011), Evolutionary Dun- of the possible characteristics. This is done by translating the geon Designer (Alvarez et al. 2018), and Sentient Sketch- structured natural language the user provides into an ASP book (Liapis, Yannakakis, and Togelius 2013); entire games, program, running the program, and translating the output including entities, relationships, and mechanics with Ger- back into natural language. By doing so, users are able to minate (Kreminski et al. 2020); and characters and items leverage some of the power of ASP without needing to be for tabletop role-playing games with Imaginarium (Horswill proficient in logic programming. This allows the generative 2020). Tanagra, Evolutionary Dungeon Designer, and Sen- tool to be approachable for users with many different back- tient Sketchbook present approachable interfaces that allow grounds, since the technical barrier to entry has been signif- users to interact directly with the content that is being gener- icantly reduced. ated and receive support or inspiration from a generative sys- Beyond the work presented in Germinate and Imaginar- tem. For example, in the Evolutionary Dungeon Designer, ium, several other domain-specific languages have been de- users manually edit tile-based dungeon maps, placing floor, veloped to support the creation of generative systems, such wall, enemy, and treasure tiles on a grid. At any time, users as the Grammatical Item Generation Language (GIGL; Chen can view suggested versions of the dungeon that an evolu- and Guy 2018), Ceptre (Martens 2015), and Tracery (Comp- tionary algorithm has generated based on the dungeon’s cur- ton, Filstrup et al. 2014). While not necessarily designed to rent configuration. By taking inspiration from the suggested provide casual users with access to PCG system creation dungeons, users are able to explore designs that they may (e.g., GIGL creates generators that interface with C++), not have considered otherwise. GIGL and Ceptre significantly reduce the effort required to Germinate and Imaginarium differ from Tanagra, Evo- implement generative systems. With these languages, users lutionary Dungeon Designer, and Sentient Sketchbook be- can more rapidly prototype new procedural content genera- cause they support users not only in generating artifacts, but tors or games that rely on these generative systems. Tracery, more broadly in the creation of the PCG systems that gen- on the other hand, was designed with casual users in mind erate those artifacts. These casual creators present novice- and supports the creation of grammar-based story genera- friendly interfaces for declaring constraints on generated ar- tors. By writing a marked up story similar to a Mad Libs tifacts, thereby allowing users to create their own procedural (e.g., “The boy saw the #animal# at the zoo”) and a set of content generators. replacement rules (e.g., animal → [giraffe, monkey, zebra]), Germinate, which is built on top of the Gemini game gen- users are quickly able to create systems that can generate a erator (Summerville et al. 2018), presents a domain-specific wide range of interesting stories. visual programming language that allows users to declare The tool that we present in this paper was originally in- spired most heavily by the MI-CC systems that are con- Rules for Map Generation cerned with generating individual game artifacts (i.e., Tana- The tool relies on Answer Set Programming (ASP), specifi- gra, Evolutionary Dungeon Designer, and Sentient Sketch- cally using the Clingo language (Gebser et al. 2008). Answer book). These systems inspired the high level of interactivity Set Programming allows users to specify atoms, constraints, that our tool provides to users when they are generating a and rules which the solver abides by and tries to generate tile map. However, we have recently identified the use of a valid set of atoms that meet those constraints. However, ASP-based rules to design tile map generators as a particu- while ASP is a powerful tool for constraint-based generation larly interesting application of our tool. Thus, our focus has (Smith et al. 2012), the complexities of ASP and first-order begun to shift toward developing a system that has more in logic make it largely inaccessible to casual users. Therefore, common with Germinate, where the central interaction be- we sought to translate the complex syntax of ASP into sim- ing supported is the use of a domain-specific programming ple natural language phrases that a user can use to craft tile language to define procedural content generators. map generators. Rules were created in two directions. First, we formu- lated the kinds of constraints we would expect from a gen- Current Progress erator, which included things like specifying the types and how many of each building should exist, the proximity of We have made significant progress toward developing a buildings to other buildings, and the connections between mixed-initiative casual creator tool that helps users make tile buildings. From those formulations, we implemented an ex- maps. The tool, developed with the Unity game engine, fea- ample of each in Clingo, our chosen ASP language, in order tures a map generator based on Answer Set Programming to establish that it was possible to create the rule in a gen- that can be configured by a set of natural language con- eralizable way. From there, the only remaining step was to straints. There is also an interactive representation of the create an internal C# script that queries Clingo with a file map that the user can edit at any time. By combining an (or, as we came to call it, a rule set) and awaits the response interactive map with a configurable constraint-based genera- in the form of logic atoms which indicate the layout of the tor, users are able to manually add whatever they want to the map. map and ask the generator to fill in all of the parts that they We chose to formulate rules as natural language sentences are less concerned about. Once they see what the generator where the user is able to adjust numbers and select opera- creates, the user can pick and choose any parts that they like tive words to form legal rules (see Figure 2 for some ex- and ask the generator to once again fill in the gaps. Through ample rules in the tool). Each rule has an associated C# this iterative process of co-creation between the user and the function which accepts the numbers and operative words as generator, users have the benefits of complete control over parameters and returns all necessary Clingo code for that the generated map while also having a reduced workload specific rule as a string. When the user indicates they are and the opportunity to be inspired by the generator. ready to generate a new map with their existing rules, the The tool’s interface is broken up into five different areas, proper function calls are made and all the Clingo code is which are shown in Figure 1. Area 1 displays the map that added to a base Clingo file which contains definitions about is being collaboratively generated by the user and the ASP- the domain space. The result of solving the Clingo file pro- based map generator. The map is interactive, allowing users duces the logic atoms which are parsed and displayed on the to manually add tiles in specific locations and to lock certain screen. areas of the map to let the generator know what it is allowed Users construct rules by typing strings or numbers into to overwrite. Area 2 allows users to start creating a new map input fields or by selecting values using dropdown menus. and to assign a name to the map. Clicking the button to cre- Rules are validated before being compiled into ASP code, ate a new map also brings up a window where users specify so individual rules that get passed to the generator are al- the desired height and width of the map. Area 3 shows all ways error-free. In fact, the only way for the user to pro- of the tiles that are available to the user and the generator. duce invalid rules is to leave some input fields blank, but Currently, users only have access to a small set of tiles, but this does not affect the generator because incomplete rules a future version of this tool will allow users to import their are ignored. However, it is not always true that the rules are own images as tiles. Users can click to select tiles in this area valid when taken together, since there could be contradic- and manually place them on the map. They can also right- tory constraints. The tool notifies users when a map cannot click tiles in this area to assign tags, which allow users to be generated given the rules and locked tiles on the map, but provide metadata about tiles to group them together. For ex- it does not currently do anything to highlight the potential ample, house, palace, and temple tiles might all be grouped problems. together under a “building” tag. Area 4 is the rule creation interface, which provides six rules (explained in detail in the Base Rules A base rule set contains all information that next section) that can be used to create tile map generators. Clingo needs to know about two-dimensional tile maps, such These rules can operate on both tile types and tags. Finally, that it is able to generate valid maps. The first element of the Area 5 has a “Generate new map” button that users can click base rule set is the set of dimension atoms. These define that to ask the generator to create a new map or re-generate the there are two dimensions, X and Y, which each take a nu- unlocked portions of the map that they are currently working meric input. The dimensions define the size of the map. The on. second element is a choice rule which indicates to Clingo Figure 1: The tool’s interface, with five distinct areas: (1) the interactive map, (2) a button for starting the creation of new maps, (3) the tiles available to the user and the map generator, (4) the rules that define the map generator, and (5) a button for generating new maps or re-generating the unlocked portions of the current map. that there should be exactly one tile on each dimension pair. The Adjacency rule specifies that a certain tag or tile must Finally, the concept of adjacency is established by creating have a certain number of another tag or tile adjacent to it. atoms that define vectors of movement. These step rules are It states “There are (≤, ≥, =) Count TileA adjacent to each expanded to arbitrarily large X and Y coordinates based on TileB.” The rule translates to the following ASP code: the rules used during generation. The base rule set is never exposed to the user, so they do not need to worry about creat- :- at(X, Y, TileA), ing valid maps and can focus on defining rules that generate #count{Z, N : at(Z, N, TileB), interesting maps. steplong(DX, DY, 1), Rules Presented to the User There are five main rules Z = X + DX, N = Y + DY} available to the user for crafting a tile map generator: Ad- (<, >, !=) Count. jacency, Proximity, Connection, Count, and On. The natural language and Clingo representations for these rules are laid For example, the rule “There are at least four parks adjacent out below. A sixth rule (Tile Inclusion) allows users to spec- to each palace,” indicates that wherever a palace is placed, ify which tiles the generator can use when creating a map, there should be four parks in the surrounding eight squares. thus providing a way to prevent irrelevant tiles from appear- The Proximity rule is an extrapolation of the Adjacency ing in certain maps (e.g., ocean tiles in a landlocked city). rule for a specified radius around the specific tile. It states The Count rule is the simplest of all the rules. It states “There are (≤, ≥, =) Count TileA within Dist spaces of each “There are (≥, ≤, =) Count TileA”. The rule translates to TileB”. The rule translates to the following ASP code: the following ASP code: :- at(X, Y, TileA), :- #count{X, Y : at(X, Y, house)} #count{Z, N : at(Z, N, TileB), (<, >, !=) Count. steplong(DX, DY, Dist), Z = X + DX, N = Y + DY} (<, >, !=) Count. A Count rule is satisfied if there exists a number of the spec- ified building or tag to satisfy the rule. The count rule can be used to indicate a specific number of buildings that should Using the Proximity rule instead of the Adjacency rule, our exist, or to create a range for a certain type of building. previous example could be accomplished like this: “There The Connection rule takes three tiles or tile tags as param- eters and specifies that every instance of the first tile is con- nected to every instance of the second tile by the third tile. Take, for example, the road Connection rule which states that “All Buildings are connected to all Buildings by Roads.” This guarantees that there is a connected chain of roads that links buildings to one another. It implies, as well, that, “All roads are connected to all roads by roads.” The third tile in the rule will always be connected to itself in order to achieve the rule. Intended Workflow The workflow we intend to support with this tool consists of two tasks: using rules to define a tile map generator, then iteratively collaborating with the generator to create specific map instances. The creation of a tile map generator would proceed as fol- lows: 1. Define constraints on the map generator by adding new Figure 2: Examples of (1) a Proximity rule, (2) an Adjacency rules or by loading an existing rule set. rule, (3) a Connection rule, and (4) a Tile Inclusion rule in 2. Ask the generator to create one or more new maps. the tool. 3. Inspect the generated maps and refine the set of rules that make up the map generator to better reflect your design are at least four parks within one space of each palace.” goals. The On rule directly uses the dimensions in the base rule 4. Repeat from Step 2 until the generator consistently creates set to specify whether a tile should or should not be on a spe- maps that you are satisfied with. cific coordinate. It states “All tiles in Row/Column Num are Once the generator is more or less finalized, the user TileA”. For specifying tiles in a certain row, the rule trans- would take the following steps to create a specific tile map lates to the following ASP code: instance: 1. Specify the dimensions of a new map. :- not at(X, Num, TileA). 2. Ask the generator to create new maps until you find one that interests you. As an example, the maps shown in Figure 3 use an On rule to ensure that only tiles with a Wall tag appear on the outer 3. Manually edit the map by adding tiles or locking sections edges of the map, thus creating a walled city. of the generated map that you want to keep. The last rule, and the most complicated, is the Connection 4. Ask the generator to re-generate the unlocked parts of the rule, which states “All TileA are connected to all TileB by map (see Figure 3 for an example). TileC”. The rule translates to the following ASP code: 5. Repeat from Step 3 until you have a map that you like. has_TileC. Evaluation as a Casual Creator 1 {TileC_start(X,Y) : dimX(X), dimY(Y), Since the primary purpose of this tool is to support a wide at(X, Y, TileC)} 1 :- has_TileC. range of users in the creation of tile maps and tile map gener- TileC_conn(X, Y) :- TileC_start(X, Y). ators, it is important to evaluate it in relation to Compton and TileC_conn(NX, NY) :- TileC_conn(X, Y), Mateas’ (2015) eleven design patterns for casual creators. step(DX, DY), NX = X + DX, NY = Y + DY, at(NX, NY, TileC). Instant feedback. The tool features an interactive display :- at(X, Y, TileC), not TileC_conn(X, Y). of the map being created, which is instantly generated when :- at(X, Y, TileA), the user asks for a new map. In our limited testing the gener- #count{Z, N : at(Z, N, TileC), ator has always returned a result instantly, but it is conceiv- step(DX, DY), able that some rule sets could cause the generator to slow Z = X + DX, N = Y + DY} < 1. down. To help mitigate any issues related to slow genera- :- at(X, Y, TileB), tion, we have configured the tool so an asynchronous call to #count{Z, N : at(Z, N, TileC), the Clingo generator is started whenever a rule is added or step(DX, DY), changed. Thus, when users ask the tool to generate a new Z = X + DX, N = Y + DY} < 1. map, the tool has already been working behind the scenes to generate that map. Figure 3: An example of two generated maps with the same locked section. The section to the right of the black line is locked; the generator has filled in the rest with possible arrangements of tiles that satisfy the constraints given (not shown). Chorus line. With a larger focus on supporting the cre- to overwrite, users are able to iteratively keep newly gener- ation of tile map generators, and not just individual tile ated sections of the map that they find interesting. There is maps, we will want to support the chorus line pattern by al- currently no equivalent feature for designing tile map gen- lowing users to simultaneously generate multiple maps with erators, but in the future it may be possible to suggest new the same generator. Thus, users will be able to get a feel for rules, either randomly or in a data-driven manner. the breadth of the design space their generator covers. Modifying the meaningful. The base rules that are used Simulation and approximating feedback. Since the tile to define a generic tile map generator, such as a rule for pop- maps generated by the tool are not designed for any spe- ulating each grid on the map with exactly one tile, are en- cific use case, such as a particular game, it is difficult to de- tirely hidden from the user. The user only needs to worry termine what metrics might be generally useful to include. about high-level rules for generating different types of tile Therefore, this design pattern is not addressed. maps. Entertaining evaluations. This is not applicable to the Saving and sharing. All constraints for a map generator current version of the tool because the tile maps being gen- can be saved to a JSON file, which can be loaded back into erated do not undergo any sort of evaluation. the tool at a later time or shared with other creators. These No blank canvas. As a starting point for users, we de- constraints include all rules as well as the types of tiles al- signed three base rule sets that create a city, a walled city, lowed in the map and tags used to group tiles. In the future, and a port city. These rule sets can be used to generate rea- we also plan to allow users to export individual maps that sonably interesting city maps with the click of a button, and they have created as JSON files and images. both the map and the rule sets can be modified by the user to start creating something new. Moreover, with the ability to Hosted communities. We do not currently have hosted save and share rule sets, there is potential for users to have communities, but the ability to export map generator rule community-sourced resources that prevent them from hav- sets as JSON files would support this. There is a lot of po- ing to deal with a blank canvas. tential for users to share generators that reflect different map archetypes, such as the walled city that we provide as a base Limiting actions to encourage exploration. When mod- rule set, that users can download and immediately use or ifying an individual map, users have access to just two core modify to fit their needs. actions - they can place tiles on the map and lock or unlock tiles to tell the generator which parts of the map it is allowed Modding, hacking, teaching. We currently do not pro- to overwrite. To define rules for a tile map generator, users vide support for modding or hacking the tool, but it may be only have access to five different rules, which represents a interesting to provide advanced users with an interface for significant simplification compared to creating a generator defining their own rules templates that compile into ASP. directly using ASP. Mutant shopping. By allowing users to directly interact Future Work with the tile map that is being generated and to lock or un- Moving forward with this tool, we are most interested in lock parts of the map to tell the generator what it is allowed expanding the rule creation interface to provide users with greater capabilities for creating tile map generators. How- that are similar to our system’s Adjacency and Proximity ever, as this is meant to be a casual creator tool, it will be rules. As a result, maps created by a WFC-based generator important for the tool to remain novice-friendly while also would not be as expressive as our system allows (namely, allowing advanced users to create more complex and ex- global constraints like Count and Connection would not be pressive generators. To this end, we are interested in reim- natively supported). Perhaps a combination of WFC-based plementing the rule creation interface using Blockly, which map generation and machine learning-based constraint in- has been used extensively in introductory programming en- ference could be implemented that takes advantage of both vironments (Fraser 2015). Specifically, it may be possible to of these promising directions for future work. leverage existing work that has made preliminary progress There are also several potential opportunities for expand- toward implementing Blockly in Unity-based applications ing the tool’s generative capabilities. First, we could allow (Taylor et al. 2019). Among many potential benefits, this local rules that only apply to certain parts of the map, thus will provide users with access to variables and arithmetic allowing for finer control over the maps being generated. We operators, which introduces significant potential for much could achieve this by supporting the composition of maps more expressive tile map generators. For example, if a user from multiple smaller maps, each with their own generators. wants to write a generalizable rule that places walls around Using a similar approach, it would be interesting to allow the outside of a city, they need to know what the width and users to create rulesets for different layers of a map (similar height of the map are. Additionally, having the standard look to layers in a program like Photoshop or Tiled). For exam- and feel of a popular visual programming language could al- ple, users could generate entire game levels by first creating low users with some Blockly experience to immediately feel a map layer and then adding an entity layer on top of it that comfortable with our tool. generates gameplay elements like characters or items. Fi- It will also be helpful to introduce debugging support in nally, we could add the ability to generate hex tile maps or the form of static program analysis. For example, if a user even abstract graph visualizations, not just square tile maps. adds two rules that contradict each other, the system could As a result, the tool could potentially be adapted for an en- flag these rules and notify the user that they are not com- tirely different domain like narrative generation by introduc- patible. A meta analysis of the ASP program constructed ing rules about temporal sequencing (e.g., X happens be- by the user, such as by using Gebser et al.’s spock sys- fore/after Y), types of actions and states (e.g., Actors can do tem (Gebser et al. 2007), is a promising direction for help- Action, Actors can be State), and action preconditions and ing users understand why the set of rules they have created effects (e.g., Doing Action makes an actor State). Providing may be unable to generate valid maps. Compared to our cur- support for other domains would likely require substantial rent approach, which only uses dynamic program analysis to work, but the potential to expand beyond tile maps is cer- produce generic error messages based on the compiled ASP tainly interesting. program’s satisfiability (e.g., “A map could not be generated Regardless of which directions we choose to pursue, it using this ruleset. Please check for errors.”), providing more will be essential to conduct user studies with an updated ver- immediate and localized feedback would likely be beneficial sion of the tool. We will want to evaluate how easy it is for to users. novices to use the tool, the types of generators and artifacts Another interesting direction for future work is to inves- that users are able to make with the tool, and the extent to tigate methods for inferring constraints from hand-authored which users find the tool engaging and rewarding. maps (De Raedt, Passerini, and Teso 2018) rather than re- quiring users to manually generate every rule. Users who Conclusion are more comfortable interacting with the map than author- ing rules would be able to provide examples of the types of We describe preliminary progress on a mixed-initiative tool maps they wish to generate and could select rules inferred by for the casual creation of tile maps. The tool features a small the system that reflect their design intent. Additionally, we palette of natural language rules specifically designed for tile might want to allow users to ask the system to generate some map generation tasks, thereby allowing users to design their rules for them. These rules could be randomly generated to own tile map generators without requiring knowledge of the encourage exploration in potentially novel design spaces, or underlying ASP code that the rules are compiled into. Users they could embody some machine learned intent based on are able to offload as much of the map generation task to the previous users’ interactions with the system. Thus, we could system as they desire, presenting opportunities for increased make progress toward our original goal of having users spec- efficiency and inspiration, while support for direct editing of ify only what they are interested in and allowing the compu- the map provides users with the ability to override the gen- tational system to fill in the gaps, only now this would be erator at any time. We evaluate the tool in relation to Comp- done in the space of map generator rules, not tiles on an ton and Mateas’ (2015) design patterns for casual creators individual map. Alternatively, it would be interesting to in- and find that it aligns with many of the patterns, but it will vestigate the use of WaveFunctionCollapse (WFC) to allow be important to conduct studies to better evaluate the tool’s the system to learn from hand drawn examples of maps that usability and usefulness. Moving forward, there are several users want the system to emulate. WFC has demonstrated an promising opportunities for future work, including greater impressive ability to extrapolate from examples of tiled im- rule authoring capabilities using a Blockly implementation ages (Karth and Smith 2021), which makes it very relevant of the rule interface, improved debugging support, and ex- to this work. However, WFC only infers local constraints pansion into content generation tasks beyond tile maps. References Smith, A. M.; Andersen, E.; Mateas, M.; and Popović, Z. Alvarez, A.; Dahlskog, S.; Font, J.; Holmberg, J.; Nolasco, 2012. A case study of expressively constrainable level de- C.; and Österman, A. 2018. Fostering creativity in the sign automation tools for a puzzle game. In Proceedings of mixed-initiative evolutionary dungeon designer. In Proceed- the International Conference on the Foundations of Digital ings of the 13th International Conference on the Founda- Games, 156–163. tions of Digital Games, 1–8. Smith, A. M.; and Mateas, M. 2011. Answer set program- Chen, T.; and Guy, S. J. 2018. GIGL: A domain specific ming for procedural content generation: A design space ap- language for procedural content generation with grammati- proach. IEEE Transactions on Computational Intelligence cal representations. In Fourteenth Artificial Intelligence and and AI in Games 3(3): 187–200. Interactive Digital Entertainment Conference. Smith, G.; Whitehead, J.; and Mateas, M. 2011. Tanagra: Compton, K.; Filstrup, B.; et al. 2014. Tracery: Approach- Reactive planning and constraint solving for mixed-initiative able story grammar authoring for casual users. In Seventh level design. IEEE Transactions on Computational Intelli- Intelligent Narrative Technologies Workshop. gence and AI in Games 3(3): 201–215. Compton, K.; and Mateas, M. 2015. Casual Creators. In Summerville, A.; Martens, C.; Samuel, B.; Osborn, J.; ICCC, 228–235. Wardrip-Fruin, N.; and Mateas, M. 2018. Gemini: Bidirec- tional generation and analysis of games via asp. In Four- De Raedt, L.; Passerini, A.; and Teso, S. 2018. Learning teenth Artificial Intelligence and Interactive Digital Enter- constraints from examples. In Thirty-Second AAAI Confer- tainment Conference, volume 14. ence on Artificial Intelligence. DungeonChannel.com. 2019. DunGen Dungeon Generator. Taylor, S.; Min, W.; Mott, B.; Emerson, A.; Smith, A.; URL https://dungen.app/dungen/. Wiebe, E.; and Lester, J. 2019. Position: IntelliBlox: A toolkit for integrating block-based programming into game- Fraser, N. 2015. Ten things we’ve learned from Blockly. In based learning environments. In 2019 IEEE Blocks and Be- 2015 IEEE Blocks and Beyond Workshop (Blocks and Be- yond Workshop (Blocks and Beyond), 55–58. IEEE. yond), 49–50. IEEE. Thorbjørn Lindeijer. 2008. Tiled Map Editor. URL https: Gebser, M.; Kaminski, R.; Kaufmann, B.; Ostrowski, M.; //www.mapeditor.org/. Schaub, T.; and Thiele, S. 2008. A user’s guide to gringo, clasp, clingo, and iclingo . Unity Technologies. 2005. Unity Game Engine. URL https: //www.unity.com. Gebser, M.; Pührer, J.; Schaub, T.; Tompits, H.; and Woltran, S. 2007. spock: A debugging support tool for logic programs Yannakakis, G. N.; Liapis, A.; and Alexopoulos, C. 2014. under the answer-set semantics. In Applications of Declar- Mixed-initiative co-creativity . ative Programming and Knowledge Management, 247–252. Springer. Horswill, I. 2020. A Declarative PCG Tool for Casual Users. In Sixteenth Artificial Intelligence and Interactive Digital Entertainment Conference, volume 16, 81–87. Karth, I.; and Smith, A. M. 2021. WaveFunctionCollapse: Content Generation via Constraint Solving and Machine Learning. IEEE Transactions on Games . Kreminski, M.; Dickinson, M.; Osborn, J.; Summerville, A.; Mateas, M.; and Wardrip-Fruin, N. 2020. Germinate: A Mixed-Initiative Casual Creator for Rhetorical Games. In Sixteenth Artificial Intelligence and Interactive Digital En- tertainment Conference, volume 16, 102–108. Liapis, A.; Yannakakis, G. N.; and Togelius, J. 2013. Sen- tient sketchbook: computer-assisted game level authoring . Martens, C. 2015. Ceptre: A language for modeling gener- ative interactive systems. In Eleventh Artificial Intelligence and Interactive Digital Entertainment Conference. Neufeld, X.; Mostaghim, S.; and Perez-Liebana, D. 2015. Procedural level generation with answer set programming for general video game playing. In 2015 7th Computer Sci- ence and Electronic Engineering Conference (CEEC), 207– 212. IEEE. RPGObjects.com. 2010. Tiamat the Tile Mapper. URL http: //www.rpgobjects.com/tiamat/.