Pith. sign in

REVIEW 3 major objections 4 minor 26 references

Fly, Fail, Fix: Iterative Game Repair with Reinforcement Learning and Large Multimodal Models

T0 review · 3 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read A large multimodal model paired with a fixed RL playtester can repair broken game configurations, reaching a target playtester score within ten feedback rounds.

desk verdict A clean, narrow demo of LMM-driven game repair from RL play traces; the missing cross-agent and human validation keeps the headline claim honest but not yet general. read the letter →

arxiv 2507.12666 v1 pith:PW2A7SD5 submitted 2025-07-16 cs.AI cs.LG

Alex Zook , Josef Spjut , Jonathan Tremblay This is my paper · ORCID
classification cs.AIcs.LG
keywords iterativegamerepairlargemultimodalmodelsreinforcementlearningplaytestingFlappyBirdparametertuningbehavioralfeedbackdesignautomationproceduralcontentgeneration
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

This paper tries to show that a large multimodal model can act as an automated game designer when it is paired with a reinforcement-learning playtester: the RL agent plays the current configuration, and the LMM reads what happened and edits the game's parameters to push the player's behavior toward a stated goal. In Flappy Bird, starting from five intentionally broken configurations, the LMM is given a target score of 10 and either text metrics, gameplay screenshots, or both; within at most ten iteration rounds all three feedback conditions reach the target score, while a configuration-only baseline stays at zero. The reason to care is that this closes the gap between generating game content and knowing whether that content produces the intended player experience, using only a handful of play episodes per round.

What carries the argument

The central object is the iterative repair loop itself: a fixed pretrained DQN agent (a lidar-based Flappy Bird player) generates five episodes per configuration, and the LMM designer receives the gameplay goal, the current YAML configuration, a parameter schema, and behavioral traces either as numeric summaries (score and flight time) or as a composite image strip of the last 8 seconds of play (25 frames), then returns an edited configuration limited to pipe parameters such as spacing, gap dimensions, and horizontal speed. The claim-carrying step is the LMM's ability to map observed behavior onto parameter edits; the evaluation uses the interquartile mean with bootstrap confidence intervals to compare player scores across iteration rounds.

What would settle it

A decisive test is to run the same 10-iteration loop on the same five starting configurations with several independent playtester agents or human players and check whether the configurations the LMM converges to raise their scores toward 10 too; if the tuned settings only lift the original DQN's score, the loop is coaching the bot rather than repairing the game. A cheaper check is to repeat the image-only condition with the score display masked out of the frames, since performance collapsing there would show the visual feedback was being read as a number rather than as gameplay.

Watch

Extended reading notes

Core claim

The paper claims that a generic pretrained multimodal model can reason over behavioral traces produced by a fixed RL playtester and use them to iteratively repair game mechanics. Concretely, with a pretrained lidar-based DQN playing Flappy Bird, the LMM designer is prompted to adjust pipe-related configuration parameters until the player scores 10. Text summaries alone, image strips alone, and text plus images all reach the target by the 10th iteration and are statistically indistinguishable, often hitting the target by the 5th iteration; the configuration-only condition never improves, leaving the score at zero. The paper reads this as evidence that LMMs can relate observed gameplay behavior to static design parameters and steer that behavior toward a specified objective.

Load-bearing premise

The loop assumes the fixed DQN playtester's score is a stable, human-relevant measure of difficulty across the configuration changes the designer is allowed to make; the paper itself notes the agent is brittle to player-physics edits.

Editorial extensions

If this is right

  • A game developer can give an LMM a play goal and a configuration file, let it tweak parameters, and have a fixed RL playtester verify each change, typically reaching the goal in five to ten rounds.
  • Text summaries alone are sufficient feedback for this repair loop, so games without rich telemetry can still be tuned automatically.
  • Visual feedback alone is also sufficient when the score is visible in the frames, meaning raw gameplay recordings can serve as the designer's input without extra instrumentation.
  • The configuration-only baseline's failure shows that the LMM's success depends on behavioral feedback rather than on static reasoning about rules and content.
  • Because each round needs only five short play episodes, the loop is cheap enough to be used during active game development.

Reading between the lines

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

  • The paper tunes only pipe-related parameters in Flappy Bird; if the pattern holds, the same loop could tune economy rates, spawning logic, or difficulty curves in any game that has a scripted playtester, but that generalization is not demonstrated here.
  • The image-only condition succeeds at least because the score is easily read from progress in the level, so a natural stress test is to mask the score in the frames and see whether the LMM can still infer difficulty from gameplay.
  • The paper's closing observation that the DQN degrades catastrophically on player-physics edits suggests the current loop may be steering around the agent's blind spots rather than making the game better for humans; an ensemble of heterogeneous playtesters would be a more conservative next step.
  • Open models currently undershoot the target score and struggle to emit valid YAML, but the paper expects near-future open models to close that gap.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. The paper proposes an automated game-design iteration framework in which a large multimodal model (LMM) acts as a designer, modifying a game's configuration file based on behavioral traces produced by a fixed reinforcement learning (RL) playtester. The experiments are conducted in Flappy Bird, with a pretrained lidar-based DQN as the player and GPT-4.1 as the designer. The designer is given a target score of 10 and receives either no feedback, textual play metrics, image strips from gameplay, or both. Across five initially 'broken' starting configurations and ten independent trials per condition, the authors report that the three feedback-providing conditions reliably steer the DQN's score to approximately 10 within at most ten iterations, while the config-only baseline remains at zero. The statistical analysis uses IQM with bootstrap confidence intervals from 50 additional evaluation episodes per generated configuration.

Significance. If the results hold, the paper makes a useful empirical contribution: it demonstrates that a generic pretrained multimodal model can use RL-agent behavior traces to modify game parameters toward a specified gameplay objective, and that visual traces alone can suffice. The strengths of the study include the sound statistical protocol (inter-quartile mean with bootstrap CIs, fresh evaluation episodes), the use of multiple starting configurations, and the explicit ablation of feedback modalities. The paper is also commendably candid about limitations, including the observed brittleness of the RL agent and the fact that the image condition succeeds partly because the score is visually discernible. However, the demonstrations are confined to one game, one fixed agent, and one target score, and the lack of a non-LMM baseline weakens the specific claim that the LMM is contributing through reasoning over behavioral traces rather than through a generic search over configurable parameters.

major comments (3)
  1. [§3 and §4 (Future Work)] The central claim treats the fixed DQN as a faithful proxy for player behavior, but the paper itself states in Section 4 that 'minor changes to the player physics parameters... frequently cause catastrophic degradation in agent performance despite the resulting games remaining playable to humans.' Although the prompt forbids modifying player physics, the designer is allowed to edit pipe speed, gap size, and spacing, which can interact with the lidar policy in a non-monotonic way. The authors assert in Section 2 that the lidar-based agent is 'flexible to variation to the level design,' but no data are provided to show that the DQN's score responds smoothly or monotonically across the edited parameter ranges. I would like to see a sweep or stability analysis over the editable parameters, or validation with a second agent or human players, to rule out the possibility that the LMM is merely exploiting the agent's blind spots rather than repairing the game's difficulty.
  2. [§3 (Experiments)] The only baseline is the config-only condition, which demonstrates that the LMM cannot improve the configuration without behavioral feedback. It does not establish that the LMM's edits are more effective than a simple automated parameter-search procedure, such as random search, hill-climbing, or Bayesian optimization, operating on the same score objective. Without such a non-LMM baseline, the paper's claim that the LMM is 'reasoning over behavioral traces' is not fully supported; the observed success might be achievable by any method that can map score violations to parameter adjustments. Adding a parameter-search baseline would make the contribution of the LMM explicit.
  3. [Abstract and Conclusion] The abstract and conclusion make a general claim: 'LMMs can reason over behavioral traces supplied by RL agents to iteratively refine game mechanics.' The evidence is based on a single game (Flappy Bird), a single fixed DQN agent, a single target score, and a restricted action space limited to pipe parameters. This is an acceptable proof-of-concept, but the general claim overstates the external validity. I recommend qualifying the conclusions to the tested setting, or adding a second game or a second agent type to support the broader framing.
minor comments (4)
  1. [§2] There are typographical errors: 'for it's accessibility' should be 'for its accessibility,' and footnote 2 contains 'in it's analysis' which should be 'in its analysis.'
  2. [§3 and Figure 2] The caption of Figure 2 does not identify which line color or marker corresponds to each experimental condition; the text describes the conditions, but the figure itself should be self-explanatory. Adding a legend or a more descriptive caption would improve readability.
  3. [Appendix C] The prompt code contains commented-out lines such as '# "Sessions are to passing 30 pipes, while passing fewer than 4 is considered too difficult."' and '# "Sessions are limited to a maximum score of 30, while a score below 4 is considered too difficult."'. These appear to be leftover debugging artifacts; they should be removed or their status clarified, since they could confuse readers about the actual prompt content.
  4. [Appendix D] The sentence 'While open models did not perform as well as the OpenAI models we did test a variety of text-only and text + image models' is grammatically awkward and should be rephrased for clarity.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the LMM's edits are judged by an external, pretrained RL playtester, and the reported scores are not equivalent by construction to the inputs.

full rationale

The paper's chain is an empirical control loop, not a derivation that reduces to its own inputs. The LMM receives a configuration and play traces, proposes edits, and a fixed pretrained DQN from Dirgová Luptáková et al. supplies the score that measures success. The prompt 'Aim for a score of 10' is the objective being optimized, not a fitted parameter later relabeled as a prediction. The evaluation uses 50 fresh episodes per configuration that the LMM never saw, so the reported IQM scores are not the same data that drove the edits. The only self-citations, Zook et al. (2014) and FactorSim (Sun et al., 2024), are background and related work and are not load-bearing for the central claim. The Future Work caveat that minor player-physics changes degrade the DQN is a limitation of the playtester proxy and a correctness concern about generalization to human playability, not a circularity step, because the paper does not claim the agent's score defines human-relevant game quality. No equation is derived from itself, no uniqueness theorem is imported from the authors, and no fitted input is renamed as a prediction. Therefore no specific circular step can be exhibited, and the appropriate finding is no significant circularity.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The principal burden the paper carries is the assumption that a fixed RL agent's score is a valid reward signal for design repair, plus experimental design choices (target score 10, 5 episodes, 9 iterations, 50 evaluation episodes, 8-second image strips) that are hand-selected rather than fitted. No new entities are introduced.

free parameters (5)
  • target_score = 10
    Chosen by the authors as the success criterion (Appendix C: 'Aim for a score of 10'). Not fitted; the whole loop is designed to hit it.
  • iterations_per_trial = 9
    Design choice (Section 3: 'followed by 9 sequential iterations... total of 10 configurations').
  • episodes_per_config = 5
    Each configuration evaluated with 5 player episodes (Section 3).
  • evaluation_episodes = 50
    50 additional episodes per generated configuration used for evaluation (Section 3).
  • image_strip_window = last 8s, 25 frames
    Image-only and combined conditions use one composite image per episode from the last 8 seconds of gameplay (Section 3).
assumptions (5)
  • domain assumption The pretrained DQN agent is stable and flexible enough to serve as a representative playtester across game configuration variations (Section 2: 'we found this model is flexible to variation to the level design').
    The entire loop's feedback signal is this agent's score; if the agent crashes or behaves erratically on some valid configs, the designer is optimizing noise. The authors acknowledge brittleness in Section 4.
  • domain assumption GPT-4.1 (and the open models tested) can reliably produce complete, valid YAML configuration files (Section 2; Appendix D excludes models that could not).
    The LMM's edits are only as good as its ability to emit parseable configs; open models were excluded for failing this.
  • domain assumption The score (number of pipes passed) is a faithful measure of game difficulty and quality for the design goal (Section 3).
    The target score of 10 defines success; the paper does not validate that score correlates with human-perceived difficulty or fun.
  • standard math Statistical methodology: inter-quartile mean with 5000 bootstrap samples is an appropriate estimator for RL performance (Section 3, citing Agarwal et al. 2021).
    Used to compute 95% confidence intervals in Figure 2.
  • domain assumption The five starting 'broken' configurations represent a diverse and meaningful repair task set (Appendix B).
    The demonstration's breadth depends on these configs spanning representative failure modes; no formal coverage argument is given.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Fly, Fail, Fix: Iterative Game Repair with Reinforcement Learning and Large Multimodal Models." pith.science (2026). https://pith.science/paper/PW2A7SD5

@misc{pith2026250712666,
  author       = {Pith},
  title        = {Pith review of: Fly, Fail, Fix: Iterative Game Repair with Reinforcement Learning and Large Multimodal Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PW2A7SD5}},
  note         = {Machine review of arXiv:2507.12666}
}
read the original abstract

Game design hinges on understanding how static rules and content translate into dynamic player behavior - something modern generative systems that inspect only a game's code or assets struggle to capture. We present an automated design iteration framework that closes this gap by pairing a reinforcement learning (RL) agent, which playtests the game, with a large multimodal model (LMM), which revises the game based on what the agent does. In each loop the RL player completes several episodes, producing (i) numerical play metrics and/or (ii) a compact image strip summarising recent video frames. The LMM designer receives a gameplay goal and the current game configuration, analyses the play traces, and edits the configuration to steer future behaviour toward the goal. We demonstrate results that LMMs can reason over behavioral traces supplied by RL agents to iteratively refine game mechanics, pointing toward practical, scalable tools for AI-assisted game design.

Figures

Figures reproduced from arXiv: 2507.12666 by the authors.

Figure 1
Figure 1. Overview of our AI design iteration framework. In each iteration an RL agent plays a [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Player score (IQM and 95% CI) across iterations from different starting configurations. [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Designer steps from the base config (top left) to the final generated config (bottom right). [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Player score (IQM and 95% CI) across different iterations of configuration changes. Iter [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]
Figure 5
Figure 5. Figure 5: Too fast configuration [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Too easy configuration 11 [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Too tight 1 configuration [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Too tight 2 configuration 12 [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: Too spaced out configuration 13 [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

26 extracted references · 19 canonical work pages

  1. [1]

    Deep reinforcement learning at the edge of the statistical precipice

    Rishabh Agarwal, Max Schwarzer, Pablo Samuel Castro, Aaron C Courville, and Marc Bellemare. Deep reinforcement learning at the edge of the statistical precipice. Advances in neural information processing systems, 2021

    work page 2021

  2. [2]

    The I nk S plotch E ffect: A case study on ChatGPT as a co-creative game designer

    Asad Anjum, Yuting Li, Noelle Law, M Charity, and Julian Togelius. The I nk S plotch E ffect: A case study on ChatGPT as a co-creative game designer. In International Conference on the Foundations of Digital Games, 2024

    work page 2024

  3. [3]

    Dota 2 with large scale deep reinforcement learning

    Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemyslaw Debiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Christopher Hesse, Rafal J \' o zefowicz, Scott Gray, Catherine Olsson, Jakub Pachocki, Michael Petrov, Henrique Pond \' e de Oliveira Pinto, Jonathan Raiman, Tim Salimans, Jeremy Schlatter, Jonas Schneider, Szymon...

    arXiv 1912

  4. [4]

    Playing F lappy B ird based on motion recognition using a transformer model and LIDAR sensor

    Iveta Dirgová Luptáková, Martin Kubovčík, and Jiří Pospíchal. Playing F lappy B ird based on motion recognition using a transformer model and LIDAR sensor. Sensors, 24 0 (6), 2024. ISSN 1424-8220. doi:10.3390/s24061905. URL https://www.mdpi.com/1424-8220/24/6/1905

    work page doi:10.3390/s24061905 2024

  5. [5]

    Adversarial reinforcement learning for procedural content generation

    Linus Gissl \'e n, Andy Eakins, Camilo Gordillo, Joakim Bergdahl, and Konrad Tollmar. Adversarial reinforcement learning for procedural content generation. In IEEE Conference on Games (CoG). IEEE, 2021

    work page 2021

  6. [6]

    Mastering diverse control tasks through world models

    Danijar Hafner, Jurgis Pasukonis, Jimmy Ba, and Timothy Lillicrap. Mastering diverse control tasks through world models. Nature, 640 0 (8059): 0 647--653, 2025. ISSN 1476-4687. doi:10.1038/s41586-025-08744-2

    doi:10.1038/s41586-025-08744-2 2025

  7. [7]

    Gen2Sim : Scaling up robot learning in simulation with generative models

    Pushkal Katara, Zhou Xian, and Katerina Fragkiadaki. Gen2Sim : Scaling up robot learning in simulation with generative models. In IEEE International Conference on Robotics and Automation (ICRA), pp.\ 6672--6679. IEEE, 2024

    work page 2024

  8. [8]

    PCGRL : Procedural content generation via reinforcement learning

    Ahmed Khalifa, Philip Bontrager, Sam Earle, and Julian Togelius. PCGRL : Procedural content generation via reinforcement learning. In AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment, volume 16, pp.\ 95--101, 2020

    work page 2020

Show all 26 references
  1. [9]

    Reward design with language models

    Minae Kwon, Sang Michael Xie, Kalesha Bullard, and Dorsa Sadigh. Reward design with language models. In International Conference on Learning Representations (ICLR), 2023

    2023

  2. [10]

    Eureka: Human-level reward design via coding large language models

    Yecheng Jason Ma, William Liang, Guanzhi Wang, De-An Huang, Osbert Bastani, Dinesh Jayaraman, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Eureka: Human-level reward design via coding large language models. In International Conference on Learning Representations (ICLR), 2023

    2023

  3. [11]

    DrEureka : Language model guided sim-to-real transfer

    Yecheng Jason Ma, William Liang, Hungju Wang, Sam Wang, Yuke Zhu, Linxi Fan, Osbert Bastani, and Dinesh Jayaraman. DrEureka : Language model guided sim-to-real transfer. In Robotics: Science and Systems (RSS), 2024

    2024

  4. [12]

    Human-level control through deep reinforcement learning

    Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518 0 (7540): 0 529--533, 2015

    2015

  5. [13]

    MAESTRO : Open-ended environment design for multi-agent reinforcement learning

    Mikayel Samvelyan, Akbir Khan, Michael Dennis, Minqi Jiang, Jack Parker-Holder, Jakob Foerster, Roberta Raileanu, and Tim Rockt \"a schel. MAESTRO : Open-ended environment design for multi-agent reinforcement learning. In International Conference on Learning Representations (I...

    2023

  6. [14]

    A general reinforcement learning algorithm that masters chess, shogi, and go through self-play

    David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362 0 ...

    2018

  7. [15]

    Open-ended learning leads to generally capable agents

    Adam Stooke, Anuj Mahajan, Catarina Barros, Charlie Deck, Jakob Bauer, Jakub Sygnowski, Maja Trebacz, Max Jaderberg, Michael Mathieu, Nat McAleese, et al. Open-ended learning leads to generally capable agents. arXiv preprint arXiv:2107.12808, 2021

    2021 arXiv

  8. [16]

    MarioGPT : Open-ended text2level generation through large language models

    Shyam Sudhakaran, Miguel Gonz \'a lez-Duque, Matthias Freiberger, Claire Glanois, Elias Najarro, and Sebastian Risi. MarioGPT : Open-ended text2level generation through large language models. Advances in Neural Information Processing Systems, 36, 2023

    2023

  9. [17]

    FactorSim : Generative simulation via factorized representation

    Fan-Yun Sun, SI Harini, Angela Yi, Yihan Zhou, Alex Zook, Jonathan Tremblay, Logan Cross, Jiajun Wu, and Nick Haber. FactorSim : Generative simulation via factorized representation. In Advances in Neural Information Processing Systems, 2024

    2024

  10. [18]

    Level generation through large language models

    Graham Todd, Sam Earle, Muhammad Umair Nasir, Michael Cerny Green, and Julian Togelius. Level generation through large language models. In International Conference on the Foundations of Digital Games, 2023

    2023

  11. [19]

    Czarnecki, Micha \"e l Mathieu, Andrew Dudzik, Junyoung Chung, David H

    Oriol Vinyals, Igor Babuschkin, Wojciech M. Czarnecki, Micha \"e l Mathieu, Andrew Dudzik, Junyoung Chung, David H. Choi, Richard Powell, Timo Ewalds, Petko Georgiev, Junhyuk Oh, Dan Horgan, Manuel Kroiss, Ivo Danihelka, Aja Huang, Laurent Sifre, Trevor Cai, John P. Agapiou, M...

    2019

  12. [20]

    POET : open-ended coevolution of environments and their optimized solutions

    Rui Wang, Joel Lehman, Jeff Clune, and Kenneth O Stanley. POET : open-ended coevolution of environments and their optimized solutions. In Genetic and Evolutionary Computation Conference, pp.\ 142--151, 2019

    2019

  13. [21]

    Enhanced POET : Open-ended reinforcement learning through unbounded invention of learning challenges and their solutions

    Rui Wang, Joel Lehman, Aditya Rawal, Jiale Zhi, Yulun Li, Jeffrey Clune, and Kenneth Stanley. Enhanced POET : Open-ended reinforcement learning through unbounded invention of learning challenges and their solutions. In International Conference on Machine Learning (ICML), pp.\ ...

    2020

  14. [22]

    RoboGen : Towards unleashing infinite data for automated robot learning via generative simulation

    Yufei Wang, Zhou Xian, Feng Chen, Tsun-Hsuan Wang, Yian Wang, Katerina Fragkiadaki, Zackory Erickson, David Held, and Chuang Gan. RoboGen : Towards unleashing infinite data for automated robot learning via generative simulation. In International Conference on Machine Learning,...

    2024

  15. [23]

    Holodeck: Language guided generation of 3d embodied ai environments

    Yue Yang, Fan-Yun Sun, Luca Weihs, Eli VanderBilt, Alvaro Herrasti, Winson Han, Jiajun Wu, Nick Haber, Ranjay Krishna, Lingjie Liu, Chris Callison-Burch, Mark Yatskar, Aniruddha Kembhavi, and Christopher Clark. Holodeck: Language guided generation of 3d embodied ai environment...

    2024

  16. [24]

    Envgen: Generating and adapting environments via LLMs for training embodied agents

    Abhay Zala*, Jaemin Cho*, Han Lin, Jaehong Yoon, and Mohit Bansal. Envgen: Generating and adapting environments via LLMs for training embodied agents. In First Conference on Language Modeling, 2024

    2024

  17. [25]

    Automatic playtesting for game parameter tuning via active learning

    Alexander Zook, Eric Fruchter, and Mark O Riedl. Automatic playtesting for game parameter tuning via active learning. In International Conference on the Foundations of Digital Games, 2014

    2014

  18. [26]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

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