Pith. sign in

REVIEW 3 major objections 5 minor 2 cited by

STORY2GAME: Generating (Almost) Everything in an Interactive Fiction Game

T0 review · 3 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read STORY2GAME turns an unchecked LLM story into a playable text-adventure game, generating the action code and inventing new actions as players try them.

desk verdict STORY2GAME's real contribution is a concrete pipeline for LLM-generated action code plus a runtime dynamic-action generator, but the evaluation never actually tests the claimed interactive playthrough because it teleports the player to the right rooms. read the letter →

arxiv 2505.03547 v1 pith:NONTB6SG submitted 2025-05-06 cs.AI

Eric Zhou , Shreyas Basavatia , Moontashir Siam , Zexin Chen , Mark O. Riedl This is my paper · ORCID
classification cs.AI
keywords interactivefictionlargelanguagemodelsproceduralcontentgenerationtext-basedgamesactiongameenginepreconditionsandeffectsdynamic
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

STORY2GAME tries to establish that a large language model can generate not just a story but the playable game around it: rooms, objects, characters, and the code behind every action a player types. The load-bearing move is to have the LLM annotate each story action with preconditions and effects, then compile those annotations into code that checks and updates a small world-state graph. Because actions are generated rather than picked from a fixed library, the story generator is not boxed in by a preset vocabulary of verbs. The paper further claims that when a player attempts an action outside the story, the engine can generate that action just-in-time, creating new objects or attributes and revising previously generated actions so the new behavior stays grounded in the world. The payoff would be fully generative interactive fiction whose narrative and logic both come from the same model, and the paper reports per-action compilation success above 92% for stories and roughly 80% for on-the-fly actions.

What carries the argument

The mechanism that carries the argument is the precondition/effect annotation, a lightweight planning notation an LLM is prompted to attach to every story action. Preconditions are split into fundamental checks (location, inventory), additional checks (custom attributes on objects or the player), and preceding-event requirements; effects are classified as movement, attribute setting, object creation, or object removal. These annotations do double duty: they are the specification from which the LLM writes executable code for the minimal engine, and they are the schema into which dynamic actions are generated, with new attributes propagated to prior actions through a relevance check. The engine itself is deliberately small—rooms, items, characters, inventories, a currency, and three universal commands—so that the generated code is the whole game and can be inspected for correctness.

What would settle it

Have a human or scripted player who has not seen the story play each generated game using only the three universal commands plus any story or dynamic actions, forbidding the forced-movement shortcut, and check whether they can complete the full action sequence; if completion rates fall far below the reported per-action compilation rates, the central interactivity claim is over-stated.

Watch

Extended reading notes

Core claim

The central discovery is an executable-action bridge: an LLM-generated story is rewritten as a sequence of actions, each accompanied by preconditions (where the player must be, what they must hold, what attributes must hold) and effects (movement, attribute setting, object creation, object removal), and these annotations are translated line by line into code for a minimal text-game engine. The engine keeps a graph of rooms, items, characters, and the player, with inventories and attributes, so every compiled action genuinely changes a ground-truth state rather than just producing text. The same precondition/effect structure powers dynamic action generation: for an off-script command, the LLM proposes new items, attributes, and preceding events, the engine patches the world state, and existing actions that share an affected object are revised if the new attribute is relevant. On story actions, the paper reports 92.8% to 97.2% per-action compilation success depending on story length, with 62.5% to 87.5% of stories compiling fully; on 90 dynamically generated actions it reports about 80% compilation success and about 60% semantic success against commonsense expectations.

Load-bearing premise

The success rates assume that a player who does not know the story can discover and reach the room where each action must happen through ordinary gameplay; the evaluation instead teleports the player and any required objects there before checking preconditions, so the 'play through the entire story' claim holds only if navigation and object-finding are natural.

Editorial extensions

If this is right

  • Story generation no longer has to be throttled to a hand-coded action library; any action the LLM writes into the narrative can be compiled into working engine code.
  • A player who goes off-script is not met with a dead end: the engine invents the requested action on the spot, and may introduce new objects (a torch, a key) or new attributes (strength) that create side quests.
  • Because newly created attributes can block or enable existing actions, off-script choices can have real consequences on whether the main story can still be completed, which is the difference between a game and a chatbot.
  • The paper positions this as a step toward almost fully generated game worlds: the same LLM produces story, world, and logic, while players keep creative autonomy without breaking a consistent ground-truth state.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The evaluation's forced-movement protocol—teleporting the player and objects to the right room before checking an action—means the 'play through the entire story' claim is more about compilation than about a real player's ability to navigate; a sterner test would run a player who must find rooms and objects via ordinary look and go commands.
  • The drop from roughly 80% compilation to roughly 60% semantic success on dynamic actions points at the state representation, not the LLM: actions whose effects should touch room-level properties (illuminate the forest) cannot be expressed because rooms carry no attributes, so extending the representation is the likely fix.
  • The same precondition/effect schema is a general recipe for making any LLM-generated procedure executable: constrain the model to emit pre/post conditions in a fixed schema, then compile those into code; that pattern could transfer to LLM-controlled tools or embodied agents whenever the model must actually change a world rather than just narrate.
  • A testable prediction follows: the recursion limit on preceding events (depth one) will cap the complexity of emergent side storylines, so lifting it would enable longer off-script chains but also increase the risk of the player drifting permanently away from the main story.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper presents STORY2GAME, a pipeline that uses GPT-4o-mini to generate a text-based interactive fiction game from a story, including world objects, locations, action code with preconditions and effects, and runtime just-in-time generation of new player actions. The authors evaluate action compilation success on generated stories of varying lengths and dynamic action generation on sampled verb-object pairs, reporting per-action compilation success rates of 92.8-97.2% and fully compiled stories in 62.5-87.5% of cases.

Significance. If its playability claims were validated, STORY2GAME would be a useful contribution to AI-driven game generation: it moves beyond fixed action sets by generating action code from LLM-defined preconditions and effects, and it supports just-in-time creation of new actions grounded in the game state. The paper provides concrete implementation details and a pipeline description that others could build on. However, the evaluation does not currently test the headline claim of interactive playthrough, and the authors explicitly acknowledge that dynamic actions may break game completeness. The system is not compared against baselines, and all generation stages use a single LLM, so external validity is limited.

major comments (3)
  1. [Section V-A, Table III] The initialization evaluation protocol force-moves the player and any required objects to the room of each story action before checking preconditions. This measures whether each action's compiled code passes its own preconditions given an omniscient teleportation oracle; it cannot tell whether a player can discover the required locations, navigate the map using the provided go-to action, or find objects placed in rooms. Consequently, the abstract's claim that the evaluation assesses "whether a player can interactively play through the entire generated story" is not supported by the reported results. The authors should add a true playthrough evaluation, such as a scripted agent that uses only available actions, or should revise the phrasing to claim only per-action compilation success.
  2. [Section V-B, Section IV] The dynamic-action evaluation determines semantic success by visual code inspection rather than by executing the action in the game, and compilation success only checks that preconditions can be fulfilled somewhere in the world state. Section IV-A places newly created objects randomly, and Section IV explicitly states that there is no guarantee that new actions will not break the completeness of the game. Section IV-D describes appending new attribute preconditions to existing actions without any satisfiability check, so a novel action can make a later story action unexecutable. The paper should measure whether dynamically generated actions can actually be performed by a player in context, and how often they break the story's completability.
  3. [Sections III and IV] The same GPT-4o-mini model generates the story, the preconditions and effects, the action code, the dynamic actions, and the decision about whether a new attribute is relevant to existing actions. This creates a circularity risk: the pipeline is self-consistent by construction, but the paper does not provide independent validation of story quality, action naturalness, or whether the generated actions match what a human player would attempt. The authors should report inter-annotator agreement on the semantic-success judgments, and ideally include a small human playtesting study on a subset of the generated games.
minor comments (5)
  1. [Section III-A] The text says "Following Yu et al. [20]" but reference [20] is by A. Ye, C. Cui, T. Shi, and M. O. Riedl; please correct the citation name.
  2. [Section V-A] The sentence "The generated story often does not not include Move actions" contains a double negative; it should read "does not include."
  3. [Section V-B] The phrase "We see an∼80%success rate" has missing spacing, and the sentence "Semantic success decreases by∼20%" is ambiguous between an absolute and a relative percentage drop; please clarify.
  4. [Figure 4] The caption states "30 total items and characters considered, each applied with 3 novel verbs" while the text says the evaluation used 15 items and 15 characters over 5 stories; please reconcile the numbers.
  5. [Section V-A] The discussion of compilation failures mentions only object misidentification; adding a brief error analysis with examples of other failure types would strengthen the evaluation.

Circularity Check

1 steps flagged · score 6.0 of 10

The playthrough claim is self-defined: Section V-A marks an action successful whenever the LLM's own preconditions hold after force-teleporting the player and objects, so the headline 'interactive playthrough' evaluation reduces to internal consistency of the generator's annotations.

  1. self definitional [Section V-A, Game World Initialization Experiments (paragraph 1)]
    "Thus, if the player or any other object is not in the required location, we force the player and/or object to move to the location that the action takes place. After forcing movement, if no precondition check fails, we mark the action as successful."

    The abstract claims the evaluation measures 'whether a player can interactively play through the entire generated story.' In the protocol, an action succeeds iff the LLM-generated fundamental preconditions hold after the evaluator force-teleports the player and required objects to the action's room. Those preconditions were produced by the same LLM (Section III-A) and then 'directly translated into code' (Section III-C). The reported success rate is therefore, by construction, the rate at which generated code checks the generator's own annotations under an oracle that removes navigation. Missing or wrong movement effects cannot lower the score because location preconditions are re-force-satisfied at every step.

full rationale

The paper is an LLM pipeline paper with no formal derivation. Aside from the self-defined playthrough metric, cited works by the same authors (e.g., [6], [20]) are used as methodological precedent or future-work pointers, not as load-bearing evidence for the paper's claims. The dynamic-action semantic evaluation uses visual inspection by humans, which is external. However, the central evaluation of the main claim—interactive playability—is not external: the success predicate is the model's own precondition/effect annotations, made trivially satisfiable for locomotion via forced movement. This is a partial circularity because the reported numbers cannot distinguish a playable game from a game whose code merely matches its own specification. The score is 6 rather than 8-10 because the compilation step is objective and there is some independent content in human code inspection, but the headline playability claim reduces by construction.

Assumptions & free parameters 5 free parameters · 4 assumptions · 3 invented entities

The system's central claim rests on the LLM's ability to produce semantically consistent annotations and code, plus the adequacy of the minimal world representation. The listed free parameters are hand-chosen design decisions that directly affect the evaluation outcomes. The invented entities are in-game constructs generated at runtime; they have no independent empirical validation outside the game. No numerical constants are fitted to external data.

free parameters (5)
  • Maximum preceding-events depth = 1
    Section IV-C caps the recursion depth of generated preceding events at one to avoid infinite cascades; this arbitrary design choice limits the complexity of dynamic action prerequisites and affects the dynamic-action evaluation.
  • Attribute value scale = binary (True/False) or integer 0 to 10
    Section IV-B restricts generated attributes to binary or small integer scales; this is a hand-chosen constraint on the expressiveness of world state definitions.
  • Verbs per item/character (evaluation) = 3
    In Section V-B, the authors prompt the LLM for exactly three novel verbs per object/character to build a 90-action test set; the choice of three is arbitrary and shapes the reported success numbers.
  • Story length bucket boundaries = 5-7, 8-10, 11-13, 14+
    Section V groups generated stories into four length buckets with 8 stories each; the boundaries are selected by the authors without justification and affect the granularity of the reported success rates.
  • Room placement strategy = random adjacent cardinal direction (N/S/E/W)
    Section III-B places each successive room in a random compass direction relative to the previous room; this is a simplistic design choice that influences map connectivity and navigational difficulty.
assumptions (4)
  • domain assumption The LLM reliably generates stories whose sentences can be annotated with consistent, executable preconditions and effects.
    Section III-A depends on GPT-4o-mini producing action annotations that are semantically faithful to the story; if the annotations are inconsistent, the generated action code will be incorrect.
  • domain assumption The minimal world representation (Player, Character, Item, Room, Container nodes with inventory and currency) can express any state required by a generated story.
    Section III-B defines the engine data model and asserts it is sufficient; stories may require state features (e.g., room-level properties) that the representation cannot express, a limitation the paper itself notes in Section V-B.
  • domain assumption Forcing the player and objects to the correct room before evaluating an action is a valid substitute for a player actually navigating to that room.
    Section V-A uses this forced-movement step in the initialization experiment, and the paper's central playability claim depends on this substitution holding.
  • domain assumption A visual inspection of generated action code by the authors is a reliable measure of whether the action matches human commonsense expectations.
    Section V-B defines semantic success this way; no external evaluators or objective tests are used, so the validity of the semantic-success results rests entirely on this assumption.
invented entities (3)
  • Dynamically generated game objects (e.g., a torch, a hammer)
    purpose: Newly created items that satisfy preconditions of player-requested actions (Section IV-A)
    These objects exist only inside the generated fiction; the paper provides no external evidence of their necessity, and their placement is randomized.
  • Dynamically generated attributes (e.g., strength, broken, distracted)
    purpose: New state variables introduced when a novel action requires or produces them (Section IV-B)
    Attributes are invented by the LLM on the fly and constrained to binary or 0-10 integers; they have no validity outside the game world.
  • The graph-based world state model with node classes
    purpose: The central data structure that grounds action execution and dynamic revision (Section III-B)
    This is a software artifact of STORY2GAME, not a discovered entity; its adequacy is assumed rather than empirically validated.

how reviews work

0 comments
Cite this review

Pith. "Pith review of STORY2GAME: Generating (Almost) Everything in an Interactive Fiction Game." pith.science (2026). https://pith.science/paper/NONTB6SG

@misc{pith2026250503547,
  author       = {Pith},
  title        = {Pith review of: STORY2GAME: Generating (Almost) Everything in an Interactive Fiction Game},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NONTB6SG}},
  note         = {Machine review of arXiv:2505.03547}
}
read the original abstract

We introduce STORY2GAME, a novel approach to using Large Language Models to generate text-based interactive fiction games that starts by generating a story, populates the world, and builds the code for actions in a game engine that enables the story to play out interactively. Whereas a given set of hard-coded actions can artificially constrain story generation, the ability to generate actions means the story generation process can be more open-ended but still allow for experiences that are grounded in a game state. The key to successful action generation is to use LLM-generated preconditions and effects of actions in the stories as guides for what aspects of the game state must be tracked and changed by the game engine when a player performs an action. We also introduce a technique for dynamically generating new actions to accommodate the player's desire to perform actions that they think of that are not part of the story. Dynamic action generation may require on-the-fly updates to the game engine's state representation and revision of previously generated actions. We evaluate the success rate of action code generation with respect to whether a player can interactively play through the entire generated story.

Figures

Figures reproduced from arXiv: 2505.03547 by the authors.

Figure 1
Figure 1. Game Generation Pipeline. the world. Preconditions are statements about the state of the world that must be true for an action to be executable. Effects are statements about how the state of the world will be different if an action is executed. While both the planner by Yu et al. and our story generator create preconditions and effects for each action in a story, our approach differs by generating a text story first… view at source ↗
Figure 2
Figure 2. We prompt the LLM for the following information: [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 2
Figure 2. Dynamic Action Generation Pipeline. doing so, a Strength attribute might be assigned and a player may need to train to increase their Strength to a threshold to fight the guard. C. Preceding Event Preconditions While not strictly necessary, we find the resulting player experience more interesting when some new actions require preceding actions. For example, if a player wants to drive a broken-down car, they may need… view at source ↗
Figures from the paper (4 more)
Figure 3
Figure 3. Figure 3: Average node counts of different types based on story length [PITH_FULL_IMAGE:figures/full_fig_p006_3.png]
Figure 4
Figure 4. Figure 4: Percentage of times each category was chosen as a precondition. 30 [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Novel Action Generation Confirmation Percentiles [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Example output for the dynamically generated action intermediate [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Reconstructing Persistent Worlds from Narratives for Narrative-Grounded Interactive Experiences

    cs.CL 2026-08 conditional novelty 5.0 of 10

    The paper reports a reference prototype that reconstructs a persistent world from narrative text and uses that world to generate playable tile-based scenes, demonstrated on three qualitative case studies.

  2. AI-Generated Interactive Fiction for Educational Use: A Pilot Study of Perceived Comprehensibility, Coherence, and Engagement

    cs.HC 2026-08 conditional novelty 4.0 of 10

    In a 22-person pilot, AI-generated educational interactive fiction scored high on comprehensibility and length but low on story-content coherence, with quiz integration identified as the main weakness.

Reference graph

Works this paper leans on

28 extracted references · 23 canonical work pages · cited by 2 Pith papers

  1. [1]

    Interactive narrative: An intelligent systems approach,

    M. O. Riedl and V . Bulitko, “Interactive narrative: An intelligent systems approach,”AI Magazine, vol. 34, no. 1, pp. 67–77, 2013

    work page 2013

  2. [2]

    Language models are few-shot learners,

    T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, S. Agarwal, A. Herbert- V oss, G. Krueger, T. Henighan, R. Child, A. Ramesh, D. M. Ziegler, J. Wu, C. Winter, C. Hesse, M. Chen, E. Sigler, M. Litwin, S. Gray, B. Chess, J. Clark, C. Berner, S. McCandlish, A. Radford, I. Sutskever, and D. Am...

    arXiv 2005

  3. [3]

    Dynamic experience management in virtual worlds for entertainment, education, and train- ing,

    M. Riedl, A. Stern, D. Dini, and J. Alderman, “Dynamic experience management in virtual worlds for entertainment, education, and train- ing,”International Transactions on Systems Science and Applications - ITSSA, vol. 4, 01 2008

    work page 2008

  4. [4]

    Dynamic generation of dilemma-based interactive narratives,

    H. Barber and D. Kudenko, “Dynamic generation of dilemma-based interactive narratives,”Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment, vol. 3, no. 1, pp. 2–7, Sep. 2021

    work page 2021

  5. [5]

    Bring- ing stories alive: Generating interactive fiction worlds,

    P. Ammanabrolu, W. Cheung, D. Tu, W. Broniec, and M. Riedl, “Bring- ing stories alive: Generating interactive fiction worlds,”Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment, vol. 16, no. 1, pp. 3–9, Oct. 2020

    work page 2020

  6. [6]

    Managing interaction between users and agents in a multi-agent storytelling environment,

    M. O. Riedl, C. Saretto, and R. M. Young, “Managing interaction between users and agents in a multi-agent storytelling environment,” inProceedings of the 2nd International Conference on Autonomous Agents and Multi-Agent Systems, Melbourne, Australia, July 2003, pp. 741–748. [Online]. Available: http://www.cc.gatech.edu/ ∼riedl/pubs/ riedl-young-aamas03.pdf

    work page 2003

  7. [7]

    Planning characters’ behaviour in interactive storytelling,

    M. Cavazza, F. Charles, and S. J. Mead, “Planning characters’ behaviour in interactive storytelling,”Comput. Animat. Virtual Worlds, vol. 13, pp. 121–131, 2002

    work page 2002

  8. [8]

    Structuring content in the fac ¸ade interactive drama architecture,

    M. Mateas and A. Stern, “Structuring content in the fac ¸ade interactive drama architecture,” inArtificial Intelligence and Interactive Digital Entertainment Conference, 2005

    work page 2005

Show all 28 references
  1. [9]

    Search-based drama management in the interactive fiction anchorhead,

    M. Nelson and M. Mateas, “Search-based drama management in the interactive fiction anchorhead,” inArtificial Intelligence and Interactive Digital Entertainment Conference, 2005

    2005

  2. [10]

    Weyhrauch,Guiding Interactive Drama, ser

    P. Weyhrauch,Guiding Interactive Drama, ser. Research paper. Carnegie-Mellon University. Department of Computer Science, 1997

    1997

  3. [11]

    If i were you: double appraisal in affective agents,

    R. Aylett and S. Louchart, “If i were you: double appraisal in affective agents,” inProceedings of the 7th International Joint Conference on Autonomous Agents and Multiagent Systems - Volume 3, ser. AAMAS ’08. Richland, SC: International Foundation for Autonomous Agents and Mu...

    2008

  4. [12]

    Scheherazade: Crowd-powered interactive narrative generation,

    B. Li and M. O. Riedl, “Scheherazade: Crowd-powered interactive narrative generation,” inProceedings of the 29th AAAI Conference on Artificial Intelligence, 2015

    2015

  5. [13]

    Say anything: Using textual case-based reasoning to enable open-domain interactive storytelling,

    R. Swanson and A. S. Gordon, “Say anything: Using textual case-based reasoning to enable open-domain interactive storytelling,”ACM Trans. Interact. Intell. Syst., vol. 2, no. 3, Sep. 2012

    2012

  6. [14]

    Toward supporting stories with procedurally generated game worlds,

    K. Hartsook, A. Zook, S. Das, and M. O. Riedl, “Toward supporting stories with procedurally generated game worlds,” inProceedings of the 2011 IEEE Symposium on Computational Intelligence and Games,

    2011

  7. [15]

    Word2world: Generating stories and worlds through large language models,

    M. U. Nasir, S. James, and J. Togelius, “Word2world: Generating stories and worlds through large language models,”ArXiv, vol. abs/2405.06686, 2024

    2024 arXiv

  8. [16]

    Starling: Self-supervised training of text-based reinforcement learning agent with large language models,

    S. Basavatia, K. Murugesan, and S. Ratnakar, “Starling: Self-supervised training of text-based reinforcement learning agent with large language models,”ArXiv, vol. abs/2406.05872, 2024

    2024 arXiv

  9. [17]

    Large language models and games: A survey and roadmap,

    R. Gallotta, G. Todd, M. Zammit, S. Earle, A. Liapis, J. Togelius, and G. N. Yannakakis, “Large language models and games: A survey and roadmap,”IEEE Transactions on Games, p. 1–18, 2024

    2024

  10. [18]

    Textworld: A learning environment for text-based games,

    M.-A. C ˆot´e, ´A. K ´ad´ar, X. Yuan, B. A. Kybartas, T. Barnes, E. Fine, J. Moore, M. J. Hausknecht, L. E. Asri, M. Adada, W. Tay, and A. Trischler, “Textworld: A learning environment for text-based games,” inCGW@IJCAI, 2018

    2018

  11. [19]

    Learning to speak and act in a fantasy text adventure game,

    J. Urbanek, A. Fan, S. Karamcheti, S. Jain, S. Humeau, E. Dinan, T. Rockt¨aschel, D. Kiela, A. Szlam, and J. Weston, “Learning to speak and act in a fantasy text adventure game,” inConference on Empirical Methods in Natural Language Processing, 2019

    2019

  12. [20]

    Neural story planning,

    A. Ye, C. Cui, T. Shi, and M. O. Riedl, “Neural story planning,” arXiv preprint arXiv:2212.08718, 2022. [Online]. Available: https: //arxiv.org/abs/2212.08718

    2022 arXiv

  13. [21]

    Emergent narrative as a novel framework for massively collaborative authoring,

    M. Kriegel and R. Aylett, “Emergent narrative as a novel framework for massively collaborative authoring,” inInternational Conference on Intelligent Virtual Agents, 2008

    2008

  14. [22]

    Diffusion models are real-time game engines,

    D. Valevski, Y . Leviathan, M. Arar, and S. Fruchter, “Diffusion models are real-time game engines,”ArXiv, vol. abs/2408.14837, 2024. APPENDIX A. Prompting Novel Actions The following is an example of how the LLM is prompted: You are creating a text-based adventure game simila...

    2024 arXiv

  15. [24]

    Move{node1}to{node2/inventory}

  16. [25]

    Set{node.some_attribute}to {value}

  17. [26]

    Add{node_name}of type {Item/Character}to {node/inventory}

  18. [27]

    Display Some message with {node.some_attribute}

  19. [28]

    Output:See Fig

    Example 1: Distracting the Guard:Input: Input: Distract the guard; room: at dungeon; preced- ing: true. Output:See Fig. 6

  20. [2011]

    Available: https://ieeexplore.ieee.org/document/6032020

    [Online]. Available: https://ieeexplore.ieee.org/document/6032020

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.