Source-linked AI summary
AI for Games in the Foundation Model Era
Meng Luo, Yanlin Li, Hao Li, Hongzhan Lin, Pengfei Zhou, Tianjie Ju, Ran Zhang, Yeying Jin, Mong-Li Lee, Wynne Hsu
TL;DR
Research on AI for games has expanded across lifecycle roles, but evidence remains fragmented about which capabilities transfer across games, engines, interfaces, and player populations. This survey organizes the field into six output-based roles and examines cross-role reuse alongside the structure and evidence required at each point of use. It finds that bounded play has stronger shared evaluation than sustained creation, adaptation, validated player modeling, and representative automated testing, making target-setting validation essential.
Problem
Research directions across game playing, modeling, design, development, runtime adaptation, and evaluation have evolved separately, limiting evidence about capability transfer across settings.
Method
The survey organizes systems into six roles by the immediate use of AI output and analyzes supplied structure, artifact reuse, capability transfer, and evidence at the point of use.
Results
Across roles, gameplay, learned environments, specifications, execution evidence, and player models form recurring exchanges, while progress remains more established for bounded play than sustained creation, adaptation, and testing.
Takeaways & Limitations
Reusing an output or capability requires re-establishing evidence in the target game, engine, interface, task, and player context.
Takeaways & Limitations
Transfer claims are constrained by possible overlap between public evaluation materials and pretraining data, while generator–evaluator agreement can reflect shared errors or judge bias.
Abstract
from arXiv · showhide
Foundation models, alongside advances in learned game-world models, are reshaping AI across the game lifecycle. Beyond playing games, recent systems model players and game dynamics, support design and development, adapt player-facing experiences at runtime, and evaluate resulting artifacts. Yet these directions have evolved largely separately, obscuring which capabilities transfer across settings and which remain tied to particular games, engines, interfaces, or player populations. We organize the literature into six roles according to the immediate use of AI output: playing and acting; modeling players and games; designing games; building and maintaining games; generating and adapting at runtime; and testing and evaluating games. For each role, we examine what structure is supplied by the game or workflow, what AI learns or produces, which capabilities and artifacts transfer across settings and roles, and what evidence supports the claims. We identify cross-role connections: trajectories train world models, learned environments provide experience for agents, design specifications drive executable implementations, and play or testing feedback guides revision. However, control schemes, rules, engine interfaces, state representations, and player contexts often remain setting-specific, so downstream claims require validation in the target setting. Evaluation is most standardized for bounded game playing and selected learned environments, while persistent state in learned worlds, repeated software revision, validated player modeling, sustained runtime adaptation, and representative automated testing remain less established. The central challenge is to reuse or transfer outputs and capabilities across roles while re-establishing evidence for effectiveness in the game-specific contexts where they are used.
1 Introduction
AI for games spans playing, modeling, design, development, runtime adaptation, and evaluation, with foundation models connecting these roles through language, multimodal, code, and tool interfaces. The survey emphasizes that these connections enable reuse but remain conditioned by game-specific structure and operating conditions.
- Operating conditions: The same pretrained model can perform different lifecycle roles, but its contribution depends on the task, interface, and game context.ARC-AGI-3 and Playbot exemplify distinct interactive and development uses of one model family.
- Cross-role connections: Foundation models connect established tasks by turning natural-language intentions into inspectable plans, generated assets, executable code, and playtest feedback.DreamGarden and Play2Code illustrate language- and tool-mediated development workflows.
- Cross-role connections: Gameplay traces can train learned simulators, support agent training, and provide diagnostic evidence, while learned environments can supply experience for game-playing agents.These exchanges connect acting, modeling, development, and evaluation without implying a mandatory pipeline.
- Six roles: Recent systems place AI across six lifecycle roles, from acting and modeling to designing, building, runtime adaptation, and testing.The survey organizes systems by the immediate use of their outputs rather than by architecture.
- Evidence: The survey argues that progress remains task-dependent, with stronger shared benchmarks for bounded play than for sustained creation, adaptation, and human experience.Its synthesis compares methods and evidence under their actual operating conditions across the six roles.
2 Roles Across the Game Lifecycle
The survey classifies AI-for-games systems by the immediate use of their outputs across six lifecycle roles, while separately tracking supplied structure, transfer, reuse, and evidence. Roles can overlap within systems, so primary placement follows the output’s immediate purpose.
- Recurring inquiries: Boundary analysis separates structure supplied by the game or workflow from what AI learns, generates, predicts, or revises.Relevant supplied structure includes rules, interfaces, state, requirements, and player context.
- Recurring inquiries: Transfer requires demonstrated competence under changed settings, whereas reuse concerns artifacts or representations consumed by another component.Sharing a pretrained backbone or passing an artifact between components alone does not establish transfer.
- Roles and boundaries: The taxonomy distinguishes six output uses: acting, modeling, design, building, runtime adaptation, and testing or evaluation.It classifies outputs rather than architectures, and roles are not mutually exclusive at the system level.
- Assigning roles: Primary placement follows the immediate use of an output: proposals map to design, executable artifacts to building, live effects to runtime adaptation, and test traces or judgments to evaluation.A single system may receive secondary roles when its outputs serve additional purposes.
- Survey organization: Figures and the system index organize representative systems by publication timeline, topic-based taxonomy, and primary or secondary roles.The role groupings cover playing, modeling, design, building, runtime generation and adaptation, and testing.
3 AI That Plays and Acts
AI that plays and acts is organized around transfer across games, interfaces, tasks, and teammates. The literature distinguishes reusable procedures, parameters, representations, and information from game-specific control and coordination requirements.
- Algorithm reuse: Strong performance in one game and transfer to another are separate achievements, because algorithm reuse, policy retraining, procedural variation, and shared parameters support different generalization claims.Held-out maps, modes, and entire games test progressively broader changes, and success may still reflect shared skills rather than unfamiliar rule reasoning.
- Learning and control hierarchies: Generalist performance depends on what changes between settings, including visual appearance, objectives, controls, timing, and interaction protocols.Shared visual encoders, language goals, and semantic APIs support different forms of reuse, but native controls and action meanings remain game-specific.
- Learning and control hierarchies: Memory and planning systems combine distinct forms of game-specific knowledge, but small fixed-difficulty ablations support exploratory rather than general claims about bounded memory.Optimus-1 retrieves crafting dependencies from a knowledge graph and uses compressed multimodal episodes for reflection, while memory units can affect correction as well as capacity.
- Learning and control hierarchies: Language planners and hierarchical agents connect task reasoning to execution, but specialist controllers, learned behavior tokens, executable skills, and native controls provide different kinds of reuse.A model may know a goal while lacking the perception, navigation, timing, or interaction policy needed to complete it.
- Test-time adaptation: Test-time adaptation differs in both supplied information and interaction cost: retrieval provides demonstrations, whereas rule discovery requires experimentation.Unfamiliar-game comparisons therefore need to account for what the agent receives and how much interaction it spends acquiring information.
- NPCs and teammates: Playing well with unfamiliar teammates is a separate transfer problem because shared weights or self-play can preserve conventions that new partners do not share.Other-Play and Fictitious Co-Play explicitly address partner variation, while task success alone does not establish compatibility with people.
4 AI That Models Players and Games
AI systems model game dynamics through learned simulators, explicit structured state, and rendering supervision, while player models increasingly target human actions and engagement. Across these settings, control semantics, event representations, rollout consistency, and target-population validation constrain transfer.
- Modeling game dynamics: Learned environments can support policy improvement, yet long-horizon success remains difficult under changing policies or fixed offline data.Dreamer 4 uses 2,500 hours of action-labeled data; its policy obtains an iron pickaxe in 29% of episodes and diamonds in 0.7% within 60-minute tasks.
- Modeling game dynamics: State-aware models improve game-mechanics fidelity by predicting explicit variables alongside visual observations, but different state dimensions require separate records and tests.StatePlay reports normalized state error below 0.06 and an 18.6-point gain over the strongest stateless baseline on mechanics-fidelity judgments; WorldMind is preferred in approximately 70% of pairwise comparisons for tactical appropriateness and coherence.
- Modeling players: Player modeling must encode event semantics and temporal context because the same sequence format can represent motor behavior, strategy, or population-level activity.The survey emphasizes that reuse across games requires an account of event correspondence, and that embeddings should be validated by what they predict.
- Modeling players: Foundation-model engagement prediction remains weak across unfamiliar games, while retention and churn are behavioral outcomes that require validation against real player populations.Zero-shot predictions often fail to beat per-game majority-class baselines, retrieval augmentation helps some pointwise predictions, and pairwise engagement-change prediction remains difficult.
- Interactive simulation: Interactive simulators expose trade-offs among action semantics, response time, temporal consistency, and rollout cost rather than solving control through visual quality alone.Incantation reports 89% action-control accuracy versus 43% for an action-index baseline, while AlayaRenderer-Flash reports 31.54 fps on one H200 and 30 fps in a live SuperTuxKart integration after target-game fine-tuning.
5 AI That Designs Games
AI game design systems generate and revise assets, levels, worlds, rules, mechanics, and narratives under playability and representation constraints. Foundation models broaden language and multimodal control, but useful transfer depends on game-specific representations, constraints, and validation.
- Content and world generation: Playable content generation combines search-based, language-conditioned, and engine-compatible 3D approaches, each requiring mechanisms that reconcile requests with game rules.Validity may come from explicit constraints, search, learned examples, or repair, while language conditioning changes how designers express requests.
- Language-conditioned generation: 88.4% of 250 MarioGPT levels were solved by an A* agent within five attempts, although path-based measures did not evaluate narrative quality.MarioGPT fine-tunes on 37 path-annotated levels using a game-specific tile vocabulary.
- Cross-game design transfer: Multiverse improves text–level blending across four games, with strongest gains within a genre while balanced cross-genre blending remains harder.Its evaluation measures structural and semantic similarity rather than execution under a new combined rule set.
- Content and world generation: 95.47% of 6,000 generation attempts were validated as repaired and anomaly-free in Unity, with layouts also imported into Left 4 Dead 2.This measures a curated-library and repair pipeline in one survival-horror setting, not unassisted language-model generation.
- Asset and scene representation: Design representations determine whether generated assets preserve gameplay roles such as collision, scale, placement, traversability, and editable behavior.DreamCraft constrains the representation itself, while database-driven methods assemble reviewed components and repair arrangements; CubePart supplies semantic parts and scripts.
- Limits and evaluation: Pretraining helps when it supplies knowledge missing from design data, but broad pretraining does not automatically improve restricted representations or difficult controls.Sokoban and MarioDiffusion show that the relevant question is which descriptions, constraints, or game vocabularies require broader knowledge.
6 AI That Builds and Maintains Games
AI systems that build and maintain games must coordinate code, scenes, assets, engine configuration, execution, debugging, and revision. Execution feedback improves inspection, but project scale and competing failure modes limit evidence for reliable construction, maintenance, and handoff.
- Project construction: Complete project construction requires agreement among code, scenes, assets, engine configuration, observations, actions, rewards, and resets.Agents expose different dependencies through graphs, component libraries, source files, editor operations, and execution feedback.
- Project construction: GameCraft-Bench evaluates 140 Godot tasks across 15 game families, with the analyzed leaderboard’s highest aggregate score reaching 68.44 out of 100.Its multimodal rubric separates mechanics, depth, visuals, and art, exposing incompleteness within otherwise recognizable projects.
- Execution and feedback: 52.0% versus 41.1%: visual feedback raises GPT-5.4’s pass rate across 333 GameDevBench tasks.The improvement comes from a richer execution-and-inspection workflow with additional tool and inference use.
- Failure modes and scale: JAMER runtime-pass rates fall from 80.4% on small projects to 5.7% on large ones, measuring 30-second headless startup runs rather than sustained interactive correctness.Mage’s direct natural-language-to-C# generation reaches a highest mean runtime-pass rate of 43% across 858 Unity attempts.
- Failure modes and scale: 55.5% of 110 GameEngineBench tasks are solved by the best configuration, while 31 tasks defeat every tested configuration.Many failures compile successfully but violate engine lifecycle, replication, or cross-system behavior.
- Maintenance and revision: Implementation quality has competing failure modes: structured representations improve mechanic adherence while reducing runtime success, and compilable edits can remain behaviorally incorrect.Maintenance additionally requires preserving unaffected behavior across cumulative requests and retaining accepted requirements with reproducible tests.
7 AI That Generates and Adapts at Runtime
Runtime systems generate or adapt dialogue, content, rules, mechanics, and difficulty during play, but their outputs must fit session state and engine constraints. Evidence spans player studies, deployments, and workflow evaluations, with benefits and limitations depending on integration and player context.
- 7 AI That Generates and Adapts at Runtime: Runtime generation covers dialogue, narrative content, rules, mechanics, memory, and personalization, with outputs increasingly integrated into live game progression.Research directions include generative content, long-term memory, dynamic rules, engine-side validation, affect models, difficulty adaptation, and adaptive characters.
- 7.2 Runtime Rules, Mechanics, and Worlds: Generated quests, behaviors, and rules require parsing, compilation, constraint checks, or engine-side validation because malformed outputs can disrupt progression or alter later strategy.Safeguards should match both the content type and the route through which it enters the engine.
- Runtime Interaction: Open dialogue can create cooperation opportunities, but only 25% of 28 players completed the full Minecraft quest when characters lacked visual or state information.Players sometimes compensated verbally for missing perception and state information, leaving progress constrained by character capabilities.
- Player Experience: In a 130-player study, model-driven characters increased perceived autonomy and cognitive load but reduced usability and trust without significantly improving overall game experience.A separate 33-player League of Legends study found that an informational and emotional companion reduced several forms of perceived challenge and tension.
- Player Experience: A 72-participant study found that dynamic item functionality and responsive NPC dialogue each improved presence, autonomy, and enjoyment, without a significant interaction between factors.The study isolates two integration choices within one farming-game prototype rather than comparing complete companion architectures.
- Player Experience: Sustained token delay harms conversational ratings more than initial waiting, showing that response timing is a distinct runtime design choice rather than a single total-latency measure.Character differences also influence ratings in the 34-participant simulated RPG study.
8 AI That Tests and Evaluates Games
Automated testing combines exploration with judgments about whether observed behavior is faulty, using coverage objectives, personas, executable checks, visual judges, and regression guidance. Results show useful progress, but conclusions remain bounded by tester competence, oracle validity, and representativeness of player behavior.
- 8 AI That Tests and Evaluates Games: Testing requires both reaching relevant behavior and recognizing faults, so coverage, observations, verdict criteria, and development usefulness must be evaluated separately.Claims about predicting player experience require human references beyond software correctness.
- Exploration objectives and coverage: Coverage-oriented objectives expose behaviors that score-maximizing policies may miss, with evolutionary, reinforcement-learning, curiosity-driven, and multi-agent methods increasing exploration across game-specific scenarios.These evaluations use game-specific objectives oracles and coverage criteria rather than treating winning as sufficient testing.
- Exploration objectives and coverage: Procedural personas and human-like testers broaden behavioral coverage, but their representativeness depends on how closely their play styles match real players.Separate execution oracles identified 45 seeded bugs across three GVG-AI games, while 427 human trajectories supplied a behavioral-similarity reference.
- 8.3 Model-Based Judges: Test oracles range from bug taxonomies and visual classifiers to multimodal judges, with supervised texture-glitch detection reaching 86.8% accuracy and 8.7% false-positive rate on generated data.Visual QA benchmarks also test anomaly recognition, temporal localization, and fault explanation across varied game scenarios.
- Executable oracles and state injection: Across 100 generated web games, state injection with vision-language and programmatic checks reached 92.2% specification-label agreement versus 58.8% for a coverage-enforced baseline, with up to 16.6× lower wall-clock time.This measures agreement on mechanic checks, not the fraction of fully correct games, and bypasses progression needed to reach target states.
- 8.3 Model-Based Judges: Model-based evaluation remains challenging: VideoGameQA-Bench reports 45.2% best visual-regression accuracy, while PlaytestArena reaches 84.2% raw criterion agreement with human judgments and κ = 0.64.Passive visual judgment does not test whether an acting tester can reach the behavior being inspected.
9 Benchmarks and Evidence Across the Six Roles
Evaluation targets and protocols differ across the six roles, so reported results support setting-specific claims rather than a common ranking. Evidence is strongest for bounded play, while transfer, fidelity, development, and evaluator independence require careful interpretation.
- Play and Act: GameWorld results distinguish partial progress from completion, with semantic action parsing not consistently outperforming direct computer use and both below two human references.The reported scores measure progress or human-relative action efficiency rather than game completion rate.
- Play and Act: 54.82 versus 99.95 for GPT-6 Astra on ARC-AGI-3 shows that the Standard harness and Provider Adapter yield sharply different scores.The comparison concerns the Semi-Private split at the reported high reasoning-effort setting; the configurations differ in reasoning-state and conversation-history management.
- Cross-role interpretation: Across role-specific benchmarks, trajectory validity, world quality, scoped development, complete construction, and control axes must be interpreted separately rather than collapsed into one leaderboard.Tables report different targets and protocols, while control adapters and task definitions differ across systems.
- Evaluation scope: Interfaces, harnesses, budgets, and retry protocols materially affect reported performance, so comparisons require matched task conditions.Symbolic state, semantic actions, pixels, tool access, latency, context length, online adaptation, and selection protocols define different evaluation problems.
- Generalization: Transfer evidence requires post-action tests such as held-out tasks, rule-sensitive interventions, reference transitions, or sustained play under stated budgets.Generated scenes or selected demonstrations alone do not establish transfer, and zero-shot use, retrieval, and target-game fine-tuning test different claims.
- Measurement validity: Evaluator labels do not guarantee independent validity: model-judged fidelity, programmatic assertions, repeated runs, and human labels remain distinct instruments.Agreement among related judges cannot replace engine checks, and aggregate accuracy can hide false negatives when most cases pass.
10 Discussion: Cross-Role Connections
Cross-role systems connect flexible model interfaces to constrained plans, tools, actions, engines, and downstream workflows. Reuse is useful only when exchanged information preserves its meaning and the receiving task demonstrates a downstream benefit.
- Interfaces and execution: Model-facing interfaces connect to constrained plans, tools, or action representations, but what a model expresses remains distinct from what a game executes.DreamGarden produces editable implementation plans, while GameWorld maps semantic actions to deterministic keyboard and mouse operations.
- Reuse and transfer: Artifact reuse can support capability transfer, but transfer must be tested under specified changes to the game, engine, interface, player population, or task.An identifiable output being consumed by another role is evidence of reuse, not competence under a changed setting.
- Information exchange: Implemented exchanges include trajectories, gameplay observations, specifications, test feedback, and player profiles, with downstream outcomes requiring separate validation.Table 13 explicitly lists outcomes to validate rather than claiming that every cited system established them.
- Information exchange: Reused information must preserve context: action traces need observations and control conventions, design plans need accepted requirements, and profiles need behavioral conditions.A recipient may parse an output correctly yet use it incorrectly if its associated meaning is lost.
- Executable and visual worlds: A production-engine workflow could separate executable rule state from visual synthesis, but asset replacement, visual inconsistency, and rendering delay can break agreement between gameplay and appearance.The proposed UE/Unity pipeline remains a research direction, and the lightweight-engine demonstration does not establish reliable project generation or maintenance.
- Evidence for connections: Compatibility, actual use, and downstream benefit are separate checks, and a playable simulation does not by itself show improved policy training in the reference game.Comparisons should hold the receiving component and total budget as constant as possible while varying the exchanged information.
11 Open Challenges and Research Directions
Open challenges concern transfer across changing games, persistent state, player-model validity, design control, software revision, and independent testing. Proposed solutions consistently pair richer representations with held-out, budgeted, and setting-specific evaluations.
- Generalist play: Transfer tests should separately vary layout, appearance, controls, rules, objectives, and partner conventions to identify which components actually generalize.Factorial tests can retain some properties while changing others, followed by joint changes under fixed real-time and interaction budgets.
- Persistent world state: Persistent world models must decide what to remember, recompute, or invalidate, because stale views and regenerated rewards can contradict changed world state.Selective explicit state should track variables whose errors alter later decisions and resolve disagreement with generated observations.
- Player modeling: Player models should distinguish stable tendencies from session-specific state and evaluate later held-out behavior, including adaptation to genuine change and resistance to misleading observations.Cross-game claims additionally require testing whether player information remains meaningful when actions and opportunities change.
- Game design: Game design systems need hard constraints, revisable preferences, diverse alternatives, and revision workflows that measure correction effort, control, artifact validity, and player experience.A richer generator may expand the practical design space or merely produce more candidates to inspect, so evaluation must follow actual revision work.
- Test and evaluate: Automated testing remains limited by missed states, faulty oracles, and unrepresentative player behavior, while optimization against imperfect evaluators can reward shortcuts.Repeated judges or prompt changes do not by themselves establish independent verification.
12 Conclusion
The survey finds that foundation models broaden AI’s roles across the game lifecycle, but effective reuse still depends on preserving game-specific structure and re-establishing evidence in the target setting. Progress therefore requires evaluation that remains valid as rules, projects, and player contexts change.
- Testing and evaluation: Additional validated defects found within a fixed testing budget, alongside false positives and reproduction cost, provide a useful outcome for automated defect discovery.Separate human-relevance sampling should include novice and expert trajectories, different strategies, and targeted fairness cases.
- Deployment: Deployment evaluations should report compute and latency, make permissions and data retention explicit, support profile correction or withdrawal, and exercise rollback or fallback.These controls apply across the six roles and matter especially for player-facing systems and evolving workflows.
- Conclusion: Progress should be assessed not only at initial success but also as game rules, project requirements, and player contexts change over time.This temporal criterion is the survey’s broadest proposed boundary for evaluating lifecycle systems.
- Conclusion: Foundation models expand interpretation, generation, prediction, and revision, but outputs remain conditioned by controls, rules, state representations, engines, interfaces, player populations, and tasks.Artifact reuse alone does not establish capability transfer, and evidence is stronger for bounded play than for persistent worlds, repeated revision, runtime adaptation, and representative testing.
A System Index
The system index organizes examples by six immediate AI roles and records their environments, mechanisms, data, and evaluation settings. It shows that evidence spans bounded play, modeling, runtime systems, development, and testing, but often remains tied to specific games, interfaces, or proxies.
- Index structure: The index separates systems into play, modeling, design, build, runtime, and test roles, with parentheses marking additional functions.Named test components are listed separately from parent systems, while dashes denote benchmarks, datasets, or frameworks.
- Playing and acting: Game-playing entries span Minecraft, Procgen, text games, roguelikes, and visual survival settings, using demonstrations, exploration, retrieval, memory, planning, or multimodal control.Evaluations include held-out environments, task completion, level generalization, and experience reuse, often under fixed game or tool setups.
- Modeling players and games: Modeling systems infer partner intent, player types, coordination, or game dynamics from structured states, trajectories, proxies, or symbolic rules.Several entries evaluate planning or coordination with proxies rather than human participants, and some focus on offline or exploratory evidence rather than online discovery.
- Testing and evaluation: Testing and evaluation use human labels, expert rubrics, VLM judgments, task annotations, narrative bug annotations, or optimal-play estimates, with reported results ranging from 45.2% visual-regression accuracy to 92.2% mean Acc@5.Some evaluations expose hallucination, forgetting, input misinterpretation, injection bypasses, or divergence between human alignment and optimal-play accuracy.
B Game Examples and Interactive Demonstrations
The examples index collects 23 game-related systems across genres and AI roles, then links selected cases to public materials. It distinguishes research demonstrations, industry reports, product features, and specialist lineages.
- Scope: Table 21 covers 23 examples across game genres and AI roles, from familiar commercial titles to generated prototypes.Twelve illustrated cases are selected for further guidance.
- Classification: The index identifies primary and secondary roles and distinguishes research demonstrations, industry reports, product features, and specialist or pre-foundation-model systems.Role codes are P for play, M for model, D for design, B for build, R for runtime, and T for test.
B.1 Racing, Team Play, and Learned Simulation
The racing, team-play, and learned-simulation examples show AI contributions operating within game-supplied rules, controls, maps, physics, or states. They combine specialist policies, grounded teammate behavior, and learned visual simulation rather than general-purpose control.
- Racing: Sophy uses a reinforcement-learning driving policy to race people, with Sophy 2.1 extending the role to selected custom-race configurations.Gran Turismo 7 supplies the tracks, vehicles, physics, race rules, and supported settings.
- Team play: Ella combines language communication with grounded teammate behavior, allowing spoken requests during PUBG battle-royale matches.The PUBG beta uses the Sanhok map, combat mechanics, controls, and action affordances.
- Learned simulation: GameNGen generates subsequent DOOM frames with an action-conditioned diffusion model trained from an RL player’s trajectories.DOOM supplies the rules and state representation, while the learned simulator produces visual continuations.
B.2 Fighting, Platforming, and Physics Puzzles
The fighting, platforming, and physics-puzzle examples condition generation on game mechanics, prompts, controls, or NPC strategies. Existing environments provide the tile vocabularies, physics, movement rules, and recorded mechanics needed to make outputs executable or reactive.
- Fighting: ReactiveGWM separately conditions generated fights on player controls and high-level NPC strategies, changing opponent reactions across offense, defense, and control strategies.The experiments use two Street Fighter titles and recorded mechanics in a research simulator.
- Platforming: MarioGPT proposes tile layouts from requests about pipes, enemies, blocks, and elevation, with levels playable or checkable using A*.An existing Mario-style environment supplies the tile vocabulary, movement rules, renderer, and controller; generation changes the level, not the engine.
- Physics puzzles: LLMs4PCG arranges blocks into letter-shaped structures from prompts, and the competition checks stability, shape resemblance, and diversity.Science Birds supplies executable physics and construction elements, making this a research platform rather than an official Angry Birds release.
B.3 Building Games and Generating Live Content
AI systems support both complete game-project construction and live content generation, but their outputs remain shaped by supplied engines, schemas, scripts, premises, and conversion rules.
- Building Games: Coding agents implement complete game projects across 15 families, including racing, roguelikes, puzzles, sports, and visual novels.Godot, task specifications, tools, and available assets are supplied; the gallery illustrates outputs, while full-task comparison appears in Table 10.
- Generating Live Content: Generated story continuations respond to player-authored tales, and words can become equipment through the game’s narrative mechanic.The game supplies the premise and conversion rules; its current disclosure identifies core art assets as human-made.
- Building Games: Text prompts generate functional objects with distinct parts, while existing behavior scripts are retargeted to the generated geometry.The beta supplies object schemas and scripts, while Roblox provides physics and the surrounding creator-configured experience.
B.4 Character Dialogue and Automated Testing
Foundation-model dialogue systems can add conversational voices to authored encounters, while learned controllers and visual agents support automated testing under explicitly supplied objectives, interfaces, and scoring rules.
- Character Dialogue: A language model generates conversational responses and a voice model delivers them in character within an otherwise authored battle-royale encounter.The character, combat behavior, game rules, and safety controls are supplied by Epic; the seasonal feature is a deployment example, not a current availability promise.
- Automated Testing: A learned helicopter controller executes testing tasks, and the same engineering study integrates zero-gravity navigation into Dead Space tests.Scripted test frameworks specify objectives and check outcomes, while reinforcement learning supplies difficult control skills within the QA workflow.
- Automated Testing: A visual agent exposes geometric and temporal inconsistencies, after which a judge scores trajectories against test rubrics.The supplied context identifies scenario goals, an action interface, and scoring rules; these are probes of generated environments rather than a commercial game.