"Press Space to Fire": Automatic Video Game Tutorial Generation
Michael Cerny Green, Ahmed Khalifa, Gabriella A. B. Barros, Julian Togelius
““Press Space To Fire”: Automatic Video Game Tutorial Generation
Michael Cerny Green, Ahmed Khalifa, Gabriella A. B. Barros, and
Julian Togelius
Tandon School of Engineering, New York University, New York, [email protected], [email protected], [email protected], [email protected]
Abstract
We propose the problem of tutorial generation for games, i.e.to generate tutorials which can teach players to play games,as an AI problem. This problem can be approached in severalways, including generating natural language descriptions ofgame rules, generating instructive game levels, and generat-ing demonstrations of how to play a game using agents thatplay in a human-like manner. We further argue that the Gen-eral Video Game AI framework provides a useful testbed foraddressing this problem.
Introduction
Artificial intelligence techniques can be used in and withgames in many different ways, to solve problems and createexperiences, as well as to advance AI. Very coarsely, AI canbe applied to generate content (Shaker, Togelius, and Nel-son 2016), play games, and model players (Yannakakis andTogelius 2017), though there are many examples of usageof AI which do not fit these categories cleanly. Looking atAI-based game design patterns, one can see AI occasionallybeing used in somewhat more obscure roles such as specta-cle, trainee or co-creator (Treanor et al. 2015).With this paper, we seek to introduce yet another interest-ing problem, and role, for AI in games. The problem is thatof generating tutorials (or instructions) and the role is that ofteacher. We can loosely define it as: given a game, generatea way to teach players how to play it .Most video games feature some kind of tutorial or instruc-tions to assist players in getting started, and creating such tu-torials is a complex task that requires skill and time. In otherwords, it is a great candidate for total or partial-automation.Furthermore, if we can find good methods for generating tu-torials, these methods can be used to help teach people toperform a large variety of other tasks.This paper surveys the (scant) literature on game tutorialsand makes a few basic distinctions between types of tuto-rials. We then discuss some possible approaches to tutorialgeneration—it turns out this problem has much in commonwith, and builds on advances in, human-like game playing aswell as procedural content generation (Shaker, Togelius, and
Copyright c (cid:13)
Nelson 2016). Finally, we discuss what it would take to gen-erate tutorials within the General Video Game AI (GVG-AI)framework.
Background
Tutorials are the first interactions players encounter in agame. They help players understand game rules and, ulti-mately, learn how to play with them. In the game indus-try, developers experimented with different tutorial formats(Therrien 2011). In the arcade era, when most games weremeant to be picked up and played quickly, they either hadvery simple mechanics, or they contained mechanics thatplayers could relate to: “Press right to move”, “Press up tojump”, and so on. As a result, these games usually lackeda formal tutorial. As their complexity increased and homeconsoles started to explode in popularity, formal tutorials be-came more common.Some game developers tried using an active learning ap-proach which was optimized for players that learn throughexperimentation and exploring carefully designed levels.Games like
Megaman X (Capcom, 1993) follow this ap-proach. Other developers relied on old-school techniques,teaching the player everything before they could play thegame, such as in
Heart of Iron 3 (Paradox Interactive, 2009).While one cannot argue that one technique is always su-perior to another, different techniques suit different audi-ences and/or games (Andersen et al. 2012; Williams 2009;Ray 2010).Tutorials have evolved significantly over time, from thesimple directive of Pong (“Avoid missing the ball for high-score”) to the exquisitely detailed in-game database of Civ-ilization (Therrien 2011). Suddaby describes multiple typesof tutorials (Suddaby 2012), from none at all to thematicallyrelevant contextual lessons , where the tutorial is ingrainedwithin the game environment.Tutorial types are related to the different learning capabil-ities of the users who play them. Sheri Graner Ray (2010)discusses different knowledge acquisition styles in additionto traditional learning styles: Explorative Acquisition andModeling Acquisition. The first style incorporates a child-like curiosity and “learning by doing”, whereas the secondis about knowing how to do something before doing it. Wecan define at least two distinct tutorial styles from this, onebeing exploratory during gameplay and the other being more a r X i v : . [ c s . A I] M a y nstructional before the game even begins.Williams suggests that active learning tutorials, whichstress player engagement and participation with the skillsbeing learned, may be ineffective when the player neverhas an isolated place to practice a particularly complexskill (Williams 2009). In fact, Williams argues that someactive learning tutorials actually ruin the entire game expe-rience for the player because of this reason. According toAndersen et al., the effectiveness of tutorials on gameplaydepends on how complex a game is to begin with (Ander-sen et al. 2012), and sometimes are not useful at all. Gamemechanics that are simple enough to be discovered usingexperimental methods may not require a tutorial to explainthem. From these two sources, we find our first two bound-aries for tutorial generation: there exists mechanics that aretoo simple to be taught in a tutorial, and there are mechan-ics complex enough that they may need to be practiced in awell-designed environment to hone.In general, a game developer would want to use the mostsuitable tutorial style for their game. For that purpose, theymust understand different dimensions/factors that affect thetutorial design process and outcome. Andersen et al. (Ander-sen et al. 2012) measured how game complexity affects theperceived outcome of tutorials. In their study, they defined 4dimensions of tutorial classification: • Tutorial Presence: whether the game has a tutorial or not. • Context Sensitivity: whether the tutorial is a part of storyand game or separate and independent from them. • Freedom: whether the player is free to experiment andexplore or is forced to follow a set of commands. • Availability of Help: whether the player can request forhelp or not.The classification proposed by Andersen et al. is binary.However, it is useful to see tutorials situated on a continuumbetween these extremes, as this allows us to gain a more nu-anced understanding of game tutorials. For example: Figure2 shows the tutorial in
Braid (Number None, Inc, 2008) fora time rewinding mechanic. The tutorial only appears basedon a certain event, i.e. the player’s death. Players will notknow about the mechanic until their first death. Instead ofhaving the tutorial available at anytime or showing how touse the mechanic at the beginning, the developer reveals itwhen it is first necessary.Sampling this space and comparing it with current gametutorials, we can find patterns repeated in multiple games.We can highlight the following tutorial types, which are notthe only tutorials present in the space, but appear to be themost common ones: • Teaching using instructions:
These tutorials explainhow to play the game by providing the player with agroup of instructions to follow, similar to what is seen inboardgames. For example: Strategy games, such as
Star-craft (Blizzard, 1998), teach the player by taking themstep by step towards understanding different aspects ofthe game. • Teaching using examples:
These tutorials explain how toplay by showing the player an example of what will hap- pen if they do a specific action. For example: Megaman Xuses a Non Playable Character (NPC) to teach the playerabout the charging skill (Egoraptor 2011). • Teaching using a carefully designed experience:
Thesetutorials explain how to play the game by giving the playerfreedom to explore and experiment. For example: in
SuperMario Bros (Nintendo, 1985), the world 1-1 is designedto introduce players to different game elements, such asgoombas and mushrooms, in a way that the player cannot miss (Credits 2014). One way of seeing that is thatearly obstacles are instances of patterns , which reoccurlater in the game in more complex instantiations or com-binations (Dahlskog and Togelius 2012).Figure 1: Street Fighters arcade cabinet. The cabinet showsdifferent combos that can be done.A game can have more than a single tutorial type from theprevious list. Arcade games used demos and instructions toboth catch the attention of the player and help them learnit. The demos help to attract more players, while simultane-ously teaching them how to play. On the other hand, showingan information screen before the game start, such as in
Pac-man (BANDAI NAMCO, 1980), or displaying instructionson the arcade cabin, frequently seen in fighting games, helpsthe player understand the game and become invested in it.Figure 1 shows
Street Fighters arcade cabinet where differ-ent characters combos and moves are written on it. Mega-man X uses a carefully designed level to teach the playerwhat to do, but still gives an example of the powershot at-tack if the player missed it.Previous work has been done related to tutorial genera-tion, especially in the area of aiding beginners, such as inBlackjack heuristics (de Mesentier Silva et al. 2016), byevolving the heuristics to be effective and concise. Simi-larly, TutorialPlan (Li, Zhang, and Fitzmaurice 2013) gener-ates text and image instructions for users to learn AutoCAD.Work has also been done in automatic tutorial generationfor API coding libraries (łł 2014), which claimed that the re-sulting generated tutorials helped users learn libraries moreeffectively than current auto-generated tutorials. Alexanderet al. postulated that open world mechanics could be trans-formed into quests (Alexander and Martens 2017). By for-igure 2: Braid teaching time rewinding mechanic when theplayer dies.malizing the game logic of Minecraft into rules, they wereable to create action graphs representing the player expe-rience, and create quests and achievements based off thoseactions.Game-O-Matic (Treanor et al. 2012) is a system whichgenerates arcade style games and instructions for them byusing a story-based concept-map inputted by a user. Afterthe game is created, Game-0-Matic generates a tutorial page,explaining who the player will control, how to control them,and winning/losing conditions, by using the concept-mapand relationships between objects within it.
How could tutorials be generated?
There already exist numerous artificial agents for a varietyof video games. We theorize that if an agent can beat a videogame, it could also build a tutorial using parts of the method-ology that it used to win. An agent could do so by construct-ing a game-mechanic graph, similar to the mission-graph asdescribed by Dormans (Dormans 2010).With the knowledge of what it takes to beat a level (orto accomplish a specific goal), the agent could construct thegraph so that leaf nodes contain terminal states, such as fin-ishing a side quest or beating the level. Nodes in betweenthe initial state and a terminal one would contain mechanicsthat lead to a terminal state such as player death or winningthe game.Figure 3 displays a tutorial graph created for
Space In-vaders (Taito, 1978). The green nodes are actions that equateto a critical victory path. Doing these actions will eventu-ally result in victory. Red nodes are a critical loss, and doingthese actions could result in losing the game. All nodes couldbe transformed into steps in a tutorial. The steps will explainhow to achieve victory, avoid loss, or other subgoals such ashow to score points. It is important to mention that nodes noton a critical path of either type can optionally be present ina tutorial and are not necessary.The graph is flexible enough to be incorporated into dif-ferent types of tutorial methods, for example those describedin the previous section using instruction , examples , and acarefully designed experience for Space Invaders: • Tutorial using instructions:
Using the text in the node as a start, a grammar could piece together sentences explain-ing each critical node on the winning and losing paths.The user would see text with phrases like “Press the leftand right arrow keys to move left and right.” • Tutorial using examples:
Since the graph was built by anagent, we can assume the agent learned these mechanicsand can replicate them. The tutorial generator could buildan example by creating a level stage that would isolatethe action or behavior contained within each node. Theuser would see a human-like artificial agent, such as onecreated by Khalifa et al. (Khalifa et al. 2016a), using theisolated movement mechanic, moving left and right on thescreen. Using a human-like AI should help ensure that itwould take similar actions to that of a human being, sothat the observing player might learn more effectively. • Tutorial using a carefully designed experience:
Thiscombines the tutorial using examples experience withlevels that revolve around the mechanics to be learned.Rather than an artificial agent playing, the player wouldbe in control. A level generator would be generating levelsbased around the critical path nodes. One such designedlevel would introduce player movement and shooting, andeventually move up to shooting aliens, finally teachingthat killing all aliens will win the level, whilst still allow-ing the player to move around freely and unrestricted.Figure 3: A Space Invaders tutorial graph. Green nodes areon a critical victory path. Red nodes are on a critical losspathA tutorial generation system for teaching using instruc-tions would require some sort of text generation engine,which would create text to be shown to the player to teachthem how to play. The most obvious choice for this wouldbe a grammar-based system, as it would allow the great-est amount of flexibility, especially over a simple text-replacement system. Grammars have been shown to behighly effective generators of content in the past (Rumel-hart 1975; Pemberton 1989; Dormans 2011; Dormans andBakkes 2011; Dart, De Rossi, and Togelius 2011; Togelius,Shaker, and Dormans 2016; Callaway and Lester 2002). Onesuch example of a grammar-based text generative tool isTracery (Compton, Filstrup, and others 2014), which wasade to generate stories with a pinch of the nonsensical. Sto-ries generated by Tracery are not bound to be causal or evenmake much sense. Past research (Lang 1999) has shown thata system that generates sophisticated story-lines requiresmassive amounts of meta-data, which is often unwieldy, ex-pensive in overhead, and arguably inflexible. Luckily, a tuto-rial generation system would not be required to tell a story,but rather teach the player how to play a game. Therefore, webelieve that a grammar-based generator will suffice, even ifit does not write causally.Another way to generate text is using an artificial agentwould explain its actions as it plays the game. Schrodt et alcreated an artificial agent to play Super Mario, which lit-erally ”thought-out-loud” as it played the game (Schrodt,R¨ohm, and Butz 2017). This technique of voicing intent ordecision during play is known as framing (Charnley, Pease,and Colton 2012). The human-like AI mentioned beforecould be modified to explain its decision-making in real-time in order to teach a human-player how to play.
GVG-AI Tutorial Generation
The GVG-AI Framework provides a testbed for researchersto solve the problem of general video game-playing artificialintelligence, a competition where competitors can designAI agents that play a variety of unseen games efficiently.Multiple competition tracks are available to compete in, in-cluding Agent (Perez-Liebana et al. 2016), Level Generation(Khalifa et al. 2016b), Multiplayer Planning (Gaina, P´erez-Li´ebana, and Lucas 2016), Learning, and Rule Generation.In this paper, we propose a method of tutorial generationand provide a possible beginning for a tutorial generationtrack for GVG-AI.Because of the wide-ranging nature of game types in theGVG-AI framework, generated tutorials would have to beapplicable to a variety of game styles and mechanics. Asall games in GVG-AI are written in VGDL, tutorial genera-tion can be done by simply reading the various interactionsand terminations in the game’s VGDL file and translating itinto an easy-to-read, concise format. Before the first level ofthe game begins, a text display demonstrating button usage,enemy types, the player, and collectibles would be shown,as well as pointing out the main goal of the game. Tutorialgeneration can be divided into mechanic discovery , graphcreation , and text generation , all of which will be describedin the following subsections. Mechanic Discovery
To generate a tutorial, our engine must first learn all rele-vant game mechanics. Using the
Sprite , Interaction , and
Ter-mination sets contained within the game’s VDGL file, theengine would record interactions between various sprites,movement controls, and terminal states. For example, Figure4 shows the interaction and termination sets for Space In-vaders. The avatar is defined in the SpriteSet to be a FlakA-vatar, which means it can shoot missiles . In the Interaction-Set, missiles that collide with EOS (End of Screen) are de-stroyed. An alternative to reading the interaction rules is using ar-tificial agents to play the game. An AI agent would explorethe game space, and discover game mechanics on its own.
Build Graph
The engine must have some way of understanding and relat-ing game mechanics to one another. We propose a graph-based rule-set interpretation. The engine would create agraph based off the discovered mechanics, where each nodecontains a mechanic of some kind. Nodes that are connectedto each other are related in some way. Leaf nodes can containterminal states for the game, such as win or loss. If the ter-minal state is a winning state, this would become a potentialcandidate for the critical path , the shortest interaction chainnecessary to win the level out of all interaction chains. Thispath would be the key goal the generator would recommenddoing. Other paths that include losing states would corre-spond to things the generator would recommend not to do.Paths that have score changes, either in a positive or negativeway, would correlate to actions the generator would recom-mend to either do often or avoid doing as much as possible.Multiple critical paths might result from this, which meansthe generator would have to find the most efficient criticalpath.Alternatively, the engine could use a human-like AI(Khalifa et al. 2016a) armed with the knowledge of thesediscovered mechanics. This agent could play the game sim-ilarly to a human player to discover the critical path. Anygame mechanics that it associates with loss would be placedon a critical loss path, and any game mechanics that it asso-ciates with winning would be placed on a critical win path.Here is an example of how the engine would build an in-teraction chain. In GVG-AI the arrow keys are assumed to bethe movement controls. Referencing Figure 4, the avatar (theplayer) is defined to be a ”FlakAvatar” which is restricted toonly horizontal movement. Thus the first green node wouldbe created with references to ”move”, ”player”, and ”left-right” movement using ”arrow keys”. Now within the inter-action set, the system would first look for associations to”avatar” to add to the chain. It would see the first interac-tion ”avatar EOS > stepBack”, which means the avatar cannot move outside the bounds of the screen. A node wouldbe created with associations to ”player”, ”not move” and”EOS” and linked to the previous node, as they are relatedvia ”avatar” and ”movement”. Generate Text with Grammar
A tutorial is not complete without some vehicle throughwhich to educate the player about the game. Using the graphof game mechanics, the engine would generate a text-basedtutorial to display instructions to the player using a gram-mar for building blocks. Grammar 1 displays an examplegrammar that could be used for a GVG-AI Tutorial Gener-ator. Using the grammar, the system would designate whichof the sentence types are applicable for a given node. Forexample. The bottom-right green node (”Player can moveleft and right (using arrow keys)”) references a behaviorabout movement (an Action Verb), the player (a Sprite),and infers arrow key controls (Control Verb and Button). tutorial (cid:105) ::= (cid:104) win (cid:105) (cid:104) lose (cid:105) (cid:104) negative (cid:105) (cid:104) positive (cid:105)(cid:104) mechanics (cid:105) (cid:104) controls (cid:105)(cid:104) win (cid:105) ::= ’To win’ (cid:104) actionVerb (cid:105) (cid:104) helpingAdj (cid:105) (cid:104) sprite (cid:105)(cid:104) lose (cid:105) ::= ’To lose’ (cid:104) actionVerb (cid:105) (cid:104) helpingAdj (cid:105) (cid:104) sprite (cid:105) | (cid:15) (cid:104) negative (cid:105) ::= ’Avoid’ (cid:104) actionVerb (cid:105) (cid:104) sprite (cid:105) (cid:104) negative (cid:105) | (cid:15) (cid:104) positive (cid:105) ::= (cid:104) actionVerb (cid:105) (cid:104) sprite (cid:105) (cid:104) positive (cid:105) | (cid:15) (cid:104) mechanics (cid:105) ::= (cid:104) mech (cid:105) (cid:104) mechanics (cid:105) | (cid:104) mech (cid:105)(cid:104) mech (cid:105) ::= (cid:104) sprite (cid:105) (cid:104) helpingVerb (cid:105) (cid:104) actionVerb (cid:105)(cid:104) helpingAdjective (cid:105) (cid:104) sprite (cid:105)(cid:104) controls (cid:105) ::= (cid:104) cont (cid:105) (cid:104) controls (cid:105) | (cid:104) cont (cid:105)(cid:104) cont (cid:105) ::= (cid:104) controlVerb (cid:105) (cid:104) button (cid:105) ’to’ (cid:104) actionVerb (cid:105) (cid:104) sprite (cid:105)(cid:104) helpingAdj (cid:105) ::= ’all’ | ’every’ | ’one’ | ’some’ | ’none’ | (cid:15) (cid:104) helpingVerb (cid:105) ::= ’can’ | ’can not’ | ’will’ | ’will not’ | (cid:15) (cid:104) actionVerb (cid:105) ::= ’move’ | ’shoot’ | ’dodge’ | ’kill’ | ’destroy’ | ’collide with’ | ’beat’ | ’lose’ | ’win’ (cid:104) controlVerb (cid:105) ::= ’press’ | ’hold’ | ’release’ (cid:104) button (cid:105) ::= ’arrow keys’ | ’left and right’ | ’space bar’Grammar 1: An example grammar for GVG-AI games.Thus the system would determine that a Control Sentencewould be most applicable to this node, and form the sentence”Press arrow keys to move player”. The second bottom-most red node (”Aliens shoot missiles”) would be deter-mined to be a Mechanic Sentence, as it references behav-iors pertaining to Alien and Alien Missile (two Sprites) and”shoot” (an Action Verb). Thus the engine would build asentence ”Alien shoots alien missile”. Of important note, < sprites > are not defined in the grammar, as they differ be-tween games in GVG-AI. Space Invaders has sprites such as“Alien” and “Missile” whereas Solarfox contains “Blib” and“PowerBlib”. Conclusion
Ideas behind designing game tutorials have evolved overtime. It is ironic that, while so much effort has been putinto generating levels, textures and stories, little to no ef-fort has been made into automatically generating what is thefirst interaction between players and the gameplay. This pa-per proposes the problem of automatically generating gametutorials through the lenses of an AI problem. It expands onthe four dimensions defined by Andersen et al (Andersenet al. 2012) for classifying different types of tutorials, andhighlights three mainstream tutorial types: Teaching usinginstructions, using examples and using a carefully designed Figure 4: Part of the rules for Aliens in VGDLexperience. It is our belief that the GVG-AI framework canbe a useful testbed for experimenting with tutorial gener-ation. Finally, we propose a graph-based rule-set interpre-tation of an agent playthrough, presented to the player as agrammar-based text tutorial. As it is, that proposal is our firstfuture step.
References [Alexander and Martens 2017] Alexander, R., and Martens,C. 2017. Deriving quests from open world mechanics. arXivpreprint arXiv:1705.00341 .[Andersen et al. 2012] Andersen, E.; O’Rourke, E.; Liu, Y.-E.; Snider, R.; Lowdermilk, J.; Truong, D.; Cooper, S.; andPopovic, Z. 2012. The impact of tutorials on games of vary-ing complexity. In
Proceedings of the SIGCHI Conferenceon Human Factors in Computing Systems , 59–68. ACM.[Callaway and Lester 2002] Callaway, C. B., and Lester,J. C. 2002. Narrative prose generation.
Artificial Intelli-gence
ICCC , 77–81.[Compton, Filstrup, and others 2014] Compton, K.; Filstrup,B.; et al. 2014. Tracery: Approachable story grammar au-thoring for casual users. In
Seventh Intelligent NarrativeTechnologies Workshop .[Credits 2014] Credits, E. 2014. Design club - super mariobros: Level 1-1 - how super mario mastered level design. .[Dahlskog and Togelius 2012] Dahlskog, S., and Togelius, J.2012. Patterns and procedural content generation: revisitingmario in world 1 level 1. In
Proceedings of the First Work-shop on Design Patterns in Games , 1. ACM.[Dart, De Rossi, and Togelius 2011] Dart, I. M.; De Rossi,G.; and Togelius, J. 2011. Speedrock: procedural rocksthrough grammars and evolution. In
Proceedings of the 2ndInternational Workshop on Procedural Content Generationin Games , 8. ACM.de Mesentier Silva et al. 2016] de Mesentier Silva, F.; Isak-sen, A.; Togelius, J.; and Nealen, A. 2016. Generatingheuristics for novice players. In
Computational Intelligenceand Games (CIG), 2016 IEEE Conference on , 1–8. IEEE.[Dormans and Bakkes 2011] Dormans, J., and Bakkes, S.2011. Generating missions and spaces for adaptable playexperiences.
IEEE Transactions on Computational Intelli-gence and AI in Games
Proceedings of the 2010 workshop on proceduralcontent generation in games , 1. ACM.[Dormans 2011] Dormans, J. 2011. Level design as modeltransformation: a strategy for automated content generation.In
Proceedings of the 2nd International Workshop on Pro-cedural Content Generation in Games , 2. ACM.[Egoraptor 2011] Egoraptor. 2011. Sequelitis - mega manclassic vs. mega man x. .[Gaina, P´erez-Li´ebana, and Lucas 2016] Gaina, R. D.;P´erez-Li´ebana, D.; and Lucas, S. M. 2016. Generalvideo game for 2 players: framework and competition. In
Computer Science and Electronic Engineering (CEEC),2016 8th , 186–191. IEEE.[Khalifa et al. 2016a] Khalifa, A.; Isaksen, A.; Togelius, J.;and Nealen, A. 2016a. Modifying mcts for human-like gen-eral video game playing. In
IJCAI , 2514–2520.[Khalifa et al. 2016b] Khalifa, A.; Perez-Liebana, D.; Lucas,S. M.; and Togelius, J. 2016b. General video game levelgeneration. In
Proceedings of the 2016 on Genetic and Evo-lutionary Computation Conference , 253–259. ACM.[Lang 1999] Lang, R. 1999. A declarative model for simplenarratives. In
Proceedings of the AAAI fall symposium onnarrative intelligence , 134–141.[Li, Zhang, and Fitzmaurice 2013] Li, W.; Zhang, Y.; andFitzmaurice, G. 2013. Tutorialplan: automated tutorial gen-eration from cad drawings. In
Twenty-Third InternationalJoint Conference on Artificial Intelligence .[Pemberton 1989] Pemberton, L. 1989. A modular approachto story generation. In
Proceedings of the fourth conferenceon European chapter of the Association for ComputationalLinguistics , 217–224. Association for Computational Lin-guistics.[Perez-Liebana et al. 2016] Perez-Liebana, D.; Samothrakis,S.; Togelius, J.; Schaul, T.; Lucas, S. M.; Cou¨etoux, A.; Lee,J.; Lim, C.-U.; and Thompson, T. 2016. The 2014 gen-eral video game playing competition.
IEEE Transactions onComputational Intelligence and AI in Games .[Rumelhart 1975] Rumelhart, D. E. 1975. Notes on a schemafor stories.
Representation and understanding: Studies incognitive science
Cognitive Robot Archi-tectures
Procedural Content Genera-tion in Games . Springer.[Suddaby 2012] Suddaby, P. 2012. The many ways toshow the player how it’s done with in-game tutorials. https://gamedevelopment.tutsplus.com/tutorials/the-many-ways-to-show-the-player-how-its-done-with-in-game-tutorials--gamedev-400 .[Therrien 2011] Therrien, C. 2011. ” to get help, please pressx” the rise of the assistance paradigm in video game design.In
DiGRA Conference .[Togelius, Shaker, and Dormans 2016] Togelius, J.; Shaker,N.; and Dormans, J. 2016. Grammars and l-systems withapplications to vegetation and levels. In
Procedural ContentGeneration in Games . Springer. 73–98.[Treanor et al. 2012] Treanor, M.; Blackford, B.; Mateas,M.; and Bogost, I. 2012. Game-o-matic: Generatingvideogames that represent ideas. In
PCG@ FDG , 11–1.[Treanor et al. 2015] Treanor, M.; Zook, A.; Eladhari, M. P.;Togelius, J.; Smith, G.; Cook, M.; Thompson, T.; Magerko,B.; Levine, J.; and Smith, A. 2015. Ai-based game designpatterns.[Williams 2009] Williams, G. C. 2009. the pedagogy ofthe game tutorial. .[Yannakakis and Togelius 2017] Yannakakis, G. N., and To-gelius, J. 2017.
Artificial Intelligence and Games . Springer. http://gameaibook.org .[łł 2014] łł. 2014.